@arka-labs/nemesis 1.2.0

package/src/commands/kairos.js

@@ -0,0 +1,216 @@
+import { installHooks, verifyHooks, removeHooks } from '../../lib/kairos/hook-installer.js';
+import { handlePreHook, handleDynamicHook, handlePostHook, handlePreCompact } from '../../lib/kairos/hook-handlers.js';
+import { titledBox } from '../../lib/ui/box.js';
+import { style } from '../../lib/ui/colors.js';
+
+const HELP = `
+nemesis kairos — Hooks & contexte agent
+
+Usage: nemesis kairos <subcommand>
+
+Subcommands:
+  hooks setup     Installe les hooks Claude Code
+  hooks status    Verifie les hooks
+  hooks remove    Desinstalle les hooks
+  push            Envoyer un evenement a un agent
+  events          Lister les evenements en attente
+  clear           Vider la queue d'un agent
+  -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];
+  const sub2 = args[1];
+
+  // Public hooks subcommands
+  if (sub === 'hooks') {
+    switch (sub2) {
+      case 'setup':  return handleHooksSetup(config);
+      case 'status': return handleHooksStatus(config);
+      case 'remove': return handleHooksRemove(config);
+      default:
+        console.log('  Usage: nemesis kairos hooks <setup|status|remove>');
+        return;
+    }
+  }
+
+  // Event bus subcommands
+  if (sub === 'push')   return handlePush(args.slice(1), flags, config);
+  if (sub === 'events') return handleEvents(args.slice(1), flags, config);
+  if (sub === 'clear')  return handleClear(args.slice(1), flags, config);
+
+  // Internal hook handlers (called by Claude Code hooks via stdin)
+  switch (sub) {
+    case 'pre-hook':      return handlePreHook(config.cwd);
+    case 'dynamic-hook':  return handleDynamicHook(config.cwd);
+    case 'post-hook':     return handlePostHook(config.cwd);
+    case 'pre-compact':   return handlePreCompact(config.cwd);
+  }
+
+  // Default
+  console.log('  Usage:');
+  console.log('    nemesis kairos hooks setup    — Installe les hooks Claude Code');
+  console.log('    nemesis kairos hooks status   — Verifie les hooks');
+  console.log('    nemesis kairos hooks remove   — Desinstalle les hooks');
+  console.log('    nemesis kairos push           — Envoyer un evenement');
+  console.log('    nemesis kairos events         — Lister les evenements');
+  console.log('    nemesis kairos clear          — Vider une queue');
+}
+
+async function handleHooksSetup(config) {
+  const result = installHooks(config.cwd);
+
+  console.log(titledBox('Kairos Hooks — Installation', [
+    `Fichier : ${result.path}`,
+    result.merged
+      ? 'Hooks merges avec la configuration existante.'
+      : 'Configuration creee.',
+    '',
+    'Hooks installes :',
+    '  SessionStart     → nemesis kairos pre-hook',
+    '  UserPromptSubmit → nemesis kairos dynamic-hook',
+    '  Stop             → nemesis kairos post-hook',
+    '  PreCompact       → nemesis kairos pre-compact',
+  ], { border: style.arkaRed }));
+}
+
+async function handleHooksStatus(config) {
+  const result = verifyHooks(config.cwd);
+
+  const icon = (ok) => ok ? style.green('✓') : style.red('✗');
+  const lines = [
+    `settings.json : ${result.settingsExists ? 'present' : style.red('ABSENT')}`,
+    '',
+    'Hooks :',
+    `  ${icon(result.hooks.SessionStart)}  SessionStart     → pre-hook`,
+    `  ${icon(result.hooks.UserPromptSubmit)}  UserPromptSubmit → dynamic-hook`,
+    `  ${icon(result.hooks.Stop)}  Stop             → post-hook`,
+    `  ${icon(result.hooks.PreCompact)}  PreCompact       → pre-compact`,
+    '',
+    result.ok
+      ? style.green('Tous les hooks sont installes.')
+      : style.yellow('ATTENTION : hooks manquants. Lancez nemesis kairos hooks setup.'),
+  ];
+
+  console.log(titledBox('Kairos Hooks — Status', lines, { border: style.arkaRed }));
+}
+
+async function handleHooksRemove(config) {
+  const result = removeHooks(config.cwd);
+
+  if (result.removed) {
+    console.log('  Hooks Kairos desinstalles.');
+  } else {
+    console.log(`  Desinstallation impossible : ${result.reason}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Event Bus subcommands
+// ---------------------------------------------------------------------------
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
+}
+
+async function handlePush(args, flags, config) {
+  const to = getFlag(args, '--to');
+  const type = getFlag(args, '--type');
+  const priority = getFlag(args, '--priority') || 'MEDIUM';
+  const message = getFlag(args, '--message') || '';
+
+  if (!to || !type) {
+    console.log('  Usage: nemesis kairos push --to <agent> --type <event_type> [--priority HIGH|MEDIUM|LOW] [--message <text>]');
+    return;
+  }
+
+  const { EVENT_TYPES } = await import('../../lib/kairos/event-bus.js');
+  const validTypes = Object.values(EVENT_TYPES);
+  if (!validTypes.includes(type)) {
+    console.log(`  Type invalide: ${type}`);
+    console.log(`  Types valides: ${validTypes.join(', ')}`);
+    return;
+  }
+
+  const validPriorities = ['HIGH', 'MEDIUM', 'LOW'];
+  if (!validPriorities.includes(priority.toUpperCase())) {
+    console.log(`  Priorite invalide: ${priority}`);
+    console.log(`  Priorites valides: ${validPriorities.join(', ')}`);
+    return;
+  }
+
+  const { routeEvent } = await import('../../lib/kairos/event-router.js');
+  const result = await routeEvent(config.cwd, {
+    target_agent_id: to,
+    event_type: type,
+    source_agent_id: 'cli',
+    priority: priority.toUpperCase(),
+    payload: message ? { message } : {},
+  });
+
+  if (result.delivered) {
+    console.log(`  ${style.green('✓')} Evenement ${type} envoye a ${to} (${result.method})`);
+    console.log(`    ${style.dim(result.detail)}`);
+  } else {
+    console.log(`  ${style.red('✗')} Echec: ${result.detail}`);
+  }
+}
+
+async function handleEvents(args, flags, config) {
+  const agentFilter = getFlag(args, '--agent');
+
+  const { pollEvents, listQueues } = await import('../../lib/kairos/event-bus.js');
+
+  if (agentFilter) {
+    const events = pollEvents(config.cwd, agentFilter);
+    if (events.length === 0) {
+      console.log(`\n  ${style.dim('Aucun evenement pour')} ${agentFilter}\n`);
+      return;
+    }
+    const lines = events.map(({ event }) =>
+      `  [${event.priority}] ${event.event_type}  de ${event.source_agent_id}  (${event.created_at})`
+    );
+    console.log(titledBox(`Events — ${agentFilter}`, lines, { border: style.arkaRed }));
+  } else {
+    const queues = listQueues(config.cwd);
+    if (queues.length === 0) {
+      console.log(`\n  ${style.dim('Aucune queue active.')}\n`);
+      return;
+    }
+    const lines = queues.map(q =>
+      `  ${q.agentId}  ${style.bold(String(q.count))} evt  ${q.oldest ? style.dim(`depuis ${q.oldest}`) : ''}`
+    );
+    console.log(titledBox('Event Bus — Queues', lines, { border: style.arkaRed }));
+  }
+}
+
+async function handleClear(args, flags, config) {
+  const agent = getFlag(args, '--agent');
+  const all = args.includes('--all');
+
+  if (!agent && !all) {
+    console.log('  Usage: nemesis kairos clear --agent <name> [--all]');
+    return;
+  }
+
+  const { clearQueue, listQueues } = await import('../../lib/kairos/event-bus.js');
+
+  if (all) {
+    const queues = listQueues(config.cwd);
+    let total = 0;
+    for (const q of queues) {
+      total += clearQueue(config.cwd, q.agentId);
+    }
+    console.log(`  ${style.green('✓')} ${total} evenement(s) purge(s) sur ${queues.length} queue(s).`);
+  } else {
+    const count = clearQueue(config.cwd, agent);
+    console.log(`  ${style.green('✓')} ${count} evenement(s) purge(s) pour ${agent}.`);
+  }
+}

package/src/commands/kars.js

@@ -0,0 +1,134 @@
+import { createHcmClient } from '../../lib/sync/hcm-client.js';
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { createSpinner } from '../../lib/ui/spinner.js';
+import { renderTable } from '../../lib/ui/table.js';
+import { formatOutput } from '../../lib/ui/format.js';
+import { style } from '../../lib/ui/colors.js';
+import { getFlag, BACK_ITEM, HOME_ITEM } from './_helpers.js';
+
+const HELP = `
+nemesis kars — Recherche profils Kairos
+
+Usage: nemesis kars search [--sector <secteur>]
+
+Subcommands:
+  search            Recherche de profils par secteur
+
+Options:
+  --sector <s>      Filtrer par secteur
+  -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: 'search', value: 'search', description: 'Recherche de profils par secteur' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'nemesis kars' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+    subArgs = [];
+  }
+
+  switch (sub) {
+    case 'search':
+      return handleSearch(subArgs, flags);
+    default:
+      console.error(`Sous-commande inconnue : ${sub}`);
+      console.log(HELP);
+  }
+}
+
+async function handleSearch(args, flags) {
+  const client = createHcmClient();
+  let sector = getFlag(args, '--sector');
+
+  // Interactive: fetch all profiles to extract sectors, then let user pick
+  if (!sector) {
+    const spinner = createSpinner('Chargement des secteurs...');
+    spinner.start();
+
+    try {
+      // q is required by the API — use 'a' to match all profiles
+      const all = await client.searchProfiles('a');
+      const profiles = Array.isArray(all) ? all : [];
+      const sectorSet = new Set();
+      for (const p of profiles) {
+        const sectors = Array.isArray(p.sectors) ? p.sectors : [];
+        for (const s of sectors) {
+          if (s) sectorSet.add(s);
+        }
+      }
+      const sectors = [...sectorSet].sort((a, b) => a.localeCompare(b, 'fr'));
+      spinner.stop(`${sectors.length} secteurs disponibles`);
+
+      if (sectors.length === 0) {
+        console.log(`\n  ${style.yellow('⚠')} Aucun secteur disponible.\n`);
+        return;
+      }
+
+      const items = sectors.map(s => ({ label: s, value: s }));
+      sector = await interactiveMenu(items, {
+        title: 'Secteur',
+        maxVisible: 15,
+      });
+      if (!sector) return;
+    } catch (err) {
+      spinner.fail('Erreur HCM');
+      console.error(`  ${err.message}\n`);
+      return;
+    }
+  }
+
+  // Fetch profiles for selected sector
+  const spinner = createSpinner(`Recherche secteur : ${sector}...`);
+  spinner.start();
+
+  try {
+    const results = await client.searchProfiles(null, sector);
+    const profiles = Array.isArray(results) ? results : [];
+    spinner.stop(`${profiles.length} profils trouves`);
+
+    if (flags.format === 'json') {
+      console.log(formatOutput(profiles, 'json'));
+      return;
+    }
+
+    if (profiles.length === 0) {
+      console.log(`\n  Aucun profil trouve pour le secteur "${sector}".\n`);
+      return;
+    }
+
+    const columns = [
+      { key: 'id', label: 'ID' },
+      { key: 'role', label: 'Role' },
+      { key: 'keywords', label: 'Keywords' },
+      { key: 'sectors', label: 'Sectors' },
+      { key: 'score', label: 'Score' },
+    ];
+
+    const rows = profiles.map(p => ({
+      id: p.id || '',
+      role: p.role || '',
+      keywords: Array.isArray(p.keywords) ? p.keywords.slice(0, 3).join(', ') : '',
+      sectors: Array.isArray(p.sectors) ? p.sectors.join(', ') : '',
+      score: p.score != null ? String(p.score) : '',
+    }));
+
+    console.log('');
+    console.log(renderTable(columns, rows));
+    console.log('');
+  } catch (err) {
+    spinner.fail('Erreur HCM');
+    console.error(`  ${err.message}\n`);
+  }
+}

package/src/commands/mission.js

@@ -0,0 +1,275 @@
+import { initMission, listMissions, inspectMission, validateMission } from '../../lib/core/mission.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 { getMissionFlowmapInfo } from '../../lib/core/flowmap/cli-helpers.js';
+import { getCurrentState } from '../../lib/core/flowmap/api.js';
+
+const HELP = `
+nemesis mission — Mission Contracts
+
+Usage: nemesis mission <subcommand> [options]
+
+Subcommands:
+  init [id]         Cree un Mission Contract
+  list              Liste les Mission Contracts
+  inspect [id]      Affiche le contenu complet d'un MCT
+  validate [id]     Valide un MC (DRAFT → VALIDATED)
+
+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 Mission Contracts' },
+      { label: 'init',     value: 'init',     description: 'Cree un Mission Contract' },
+      { label: 'inspect',  value: 'inspect',  description: 'Affiche le contenu d\'un MCT' },
+      { label: 'validate', value: 'validate', description: 'Valide un MC (DRAFT → VALIDATED)' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'nemesis mission' });
+    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 'validate':
+      return handleValidate(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 = listMissions(project.hcm_dir);
+    const prefix = `MCT-${project.id}`;
+    const suggested = nextId(prefix, existing.map(m => m.id));
+    id = await askText('ID du Mission Contract', suggested);
+  }
+  if (!id) return;
+
+  const title = await askText('Titre');
+  const summary = await askText('Resume (optionnel)', '');
+
+  const result = initMission(id, {
+    title, summary, root: config.cwd, projectId: project.id,
+  });
+
+  console.log(`\n  ${style.green('\u2713')} Mission Contract cree : ${style.bold(id)}`);
+  console.log(`  ${style.dim('\u2192')} ${result.filepath.replace(config.cwd + '/', '')}`);
+
+  // Next steps
+  const registry = readRegistry(project.hcm_dir);
+  const lanes = registry ? getLanes(registry) : [];
+
+  console.log(`\n  ${style.bold('Prochaines etapes')} :`);
+  console.log('  1. Completez le workflow (gates, task_registry)');
+  console.log(`  2. Redigez les OdMs associes : ${style.dim('nemesis odm init')}`);
+  if (lanes.length === 0) {
+    console.log(`  3. ${style.yellow('Equipe vide')} — ajoutez un agent : ${style.dim('nemesis team add')}`);
+  } else {
+    console.log(`  3. Equipe : ${lanes.length} agent(s) disponible(s)`);
+  }
+  console.log('');
+
+  // Loop — propose to create another
+  const another = await askConfirm('Creer un autre Mission Contract ?', false);
+  if (another) return handleInit([], flags, config);
+}
+
+async function handleList(flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  const missions = listMissions(project.hcm_dir);
+
+  if (flags.format === 'json') {
+    console.log(formatOutput(missions, 'json'));
+    return;
+  }
+
+  if (missions.length === 0) {
+    console.log(`\n  ${style.dim('Aucun Mission Contract.')}`);
+    const doCreate = await askConfirm('Creer un Mission Contract maintenant ?', true);
+    if (doCreate) {
+      return handleInit([], flags, config);
+    }
+    console.log('');
+    return;
+  }
+
+  // Enrich with FLOWMAP state
+  const enriched = missions.map(m => {
+    const missionId = m.id;
+    let flowmap = '-';
+    try {
+      const fmState = getCurrentState(missionId, { root: config.cwd });
+      if (fmState) flowmap = fmState.value;
+    } catch { /* no-op */ }
+    return { ...m, flowmap };
+  });
+
+  console.log('');
+  console.log(renderTable(
+    [
+      { key: 'id', label: 'ID' },
+      { key: 'title', label: 'Titre' },
+      { key: 'status', label: 'Status' },
+      { key: 'flowmap', label: 'FLOWMAP' },
+    ],
+    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 missions
+  if (!id) {
+    const missions = listMissions(project.hcm_dir);
+    if (missions.length === 0) {
+      console.log(`\n  ${style.dim('Aucun Mission Contract a inspecter.')}`);
+      const doCreate = await askConfirm('Creer un Mission Contract maintenant ?', true);
+      if (doCreate) return handleInit([], flags, config);
+      return;
+    }
+    id = await pickFromList(missions, {
+      title: 'Quel Mission Contract inspecter ?',
+      labelFn: (m) => `${m.id} — ${m.title || style.dim('(sans titre)')} [${m.status}]`,
+    });
+    if (!id) return;
+  }
+
+  const data = inspectMission(id, project.hcm_dir);
+
+  if (flags.format === 'json') {
+    console.log(formatOutput(data, 'json'));
+    return;
+  }
+
+  // Formatted view — consistent with odm inspect
+  const meta = data.contract_meta || {};
+  const payload = data.contract_payload || {};
+  const cadrage = payload.cadrage || {};
+  const workflow = payload.workflow || {};
+  const taskReg = payload.task_registry || {};
+  const tasks = Array.isArray(taskReg.tasks) ? taskReg.tasks : [];
+
+  console.log(`\n  ${style.bold('Mission Contract')} : ${style.nemesisAccent(meta.id || id)}`);
+  console.log(`  Status     : ${meta.status || '?'}`);
+  console.log(`  Owner      : ${meta.owner || '?'}`);
+  console.log(`  Projet     : ${meta.project_id || '?'}`);
+  console.log(`  Titre      : ${cadrage.title || '?'}`);
+  if (cadrage.summary) {
+    console.log(`  Resume     : ${cadrage.summary}`);
+  }
+  console.log(`  Cree le    : ${meta.created_at ? meta.created_at.split('T')[0] : '?'}`);
+
+  // Workflow
+  const gates = workflow.gates || {};
+  const gateCount = Object.keys(gates).length;
+  if (gateCount > 0) {
+    console.log(`\n  Workflow   : ${gateCount} gate(s)`);
+    for (const [name, gate] of Object.entries(gates)) {
+      console.log(`    ${style.dim('\u2192')} ${name} : ${gate.description || gate.status || '?'}`);
+    }
+  } else {
+    console.log(`\n  Workflow   : ${style.dim('(a completer)')}`);
+  }
+
+  // Task registry
+  if (tasks.length > 0) {
+    console.log(`\n  Tasks      : ${tasks.length} tache(s)`);
+    console.log(renderTable(
+      [
+        { key: 'id', label: 'ID' },
+        { key: 'title', label: 'Tache' },
+        { key: 'status', label: 'Status' },
+      ],
+      tasks,
+    ));
+  } else {
+    console.log(`  Tasks      : ${style.dim('(aucune)')}`);
+  }
+
+  // FLOWMAP
+  const missionId = meta.mission_id || meta.id || id;
+  const fmInfo = getMissionFlowmapInfo(missionId, config.cwd);
+  if (fmInfo) {
+    console.log(`\n  FLOWMAP    : ${fmInfo.state} [${fmInfo.phase}] ${fmInfo.label}`);
+    if (fmInfo.history.length > 0) {
+      console.log('\n  Historique recent :');
+      for (const h of fmInfo.history.slice(-5)) {
+        const ts = h.timestamp ? h.timestamp.replace('T', ' ').substring(0, 16) : '';
+        console.log(`  - ${h.from || '?'} \u2192 ${h.to || '?'}  ${h.event}  ${style.dim(ts)}`);
+      }
+    }
+  } else {
+    console.log(`\n  FLOWMAP    : ${style.dim('(non initialise)')}`);
+  }
+
+  console.log('');
+}
+
+async function handleValidate(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  let id = args[0];
+
+  if (!id) {
+    const missions = listMissions(project.hcm_dir);
+    const drafts = missions.filter(m => m.status === 'DRAFT');
+    if (drafts.length === 0) {
+      console.log(`\n  ${style.dim('Aucun Mission Contract en DRAFT a valider.')}\n`);
+      return;
+    }
+    id = await pickFromList(drafts, {
+      title: 'Mission Contract a valider',
+      labelFn: (m) => `${m.id} — ${m.title || style.dim('(sans titre)')} [${m.status}]`,
+    });
+    if (!id) return;
+  }
+
+  try {
+    const result = validateMission(id, project.hcm_dir);
+    console.log(`\n  ${style.green('\u2713')} Mission Contract ${style.bold(result.id)} → ${style.green('VALIDATED')}`);
+    console.log(`\n  ${style.bold('Prochaines etapes')} :`);
+    console.log(`  1. Creer les OdMs associes : ${style.dim('nemesis odm init')}`);
+    console.log(`  2. Dispatcher aux agents : ${style.dim('nemesis odm set-status <ID> READY_TO_DISPATCH + nemesis orch')}\n`);
+  } catch (err) {
+    console.log(`\n  ${style.red('\u2717')} ${err.message}\n`);
+  }
+}