@arka-labs/nemesis 1.2.0

package/lib/core/odm.js

@@ -0,0 +1,191 @@
+import { writeFileSync, existsSync, readdirSync, readFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Valid OdM status transitions.
+ */
+const VALID_TRANSITIONS = {
+  DRAFT: ['ASSIGNED', 'READY_TO_DISPATCH'],
+  ASSIGNED: ['READY_TO_DISPATCH', 'COMPLETED'],
+  READY_TO_DISPATCH: ['DISPATCHING'],
+  DISPATCHING: ['ASSIGNED', 'READY_TO_DISPATCH', 'COMPLETED'],
+};
+
+/**
+ * Set the status of an OdM with transition validation + atomic write.
+ * @param {string} id — OdM ID
+ * @param {string} newStatus — target status
+ * @param {string} hcmDir — path to .nemesis/HCM
+ * @returns {{ id: string, oldStatus: string, newStatus: string }}
+ */
+export function setOdmStatus(id, newStatus, hcmDir) {
+  const odmDir = join(hcmDir, 'odm');
+  const filepath = join(odmDir, `${id}.json`);
+
+  if (!existsSync(filepath)) {
+    throw new Error(`OdM ${id} introuvable.`);
+  }
+
+  const odm = JSON.parse(readFileSync(filepath, 'utf-8'));
+  const oldStatus = odm.odm_meta?.status;
+
+  if (!oldStatus) {
+    throw new Error(`OdM ${id} n'a pas de status.`);
+  }
+
+  const allowed = VALID_TRANSITIONS[oldStatus];
+  if (!allowed || !allowed.includes(newStatus)) {
+    throw new Error(
+      `Transition invalide : ${oldStatus} → ${newStatus}. ` +
+      `Transitions valides depuis ${oldStatus} : ${(allowed || []).join(', ') || '(aucune)'}`
+    );
+  }
+
+  odm.odm_meta.status = newStatus;
+  odm.odm_meta.updated_at = new Date().toISOString();
+
+  // Atomic write: tmp + rename
+  const tmpPath = filepath + '.tmp';
+  writeFileSync(tmpPath, JSON.stringify(odm, null, 2) + '\n', 'utf-8');
+  renameSync(tmpPath, filepath);
+
+  return { id, oldStatus, newStatus };
+}
+
+/**
+ * Assign an OdM to an agent (sets assigned_to field).
+ * @param {string} id — OdM ID
+ * @param {string} agentId — agent name/id
+ * @param {string} hcmDir — path to .nemesis/HCM
+ * @returns {{ id: string, assignedTo: string }}
+ */
+export function assignOdm(id, agentId, hcmDir) {
+  const odmDir = join(hcmDir, 'odm');
+  const filepath = join(odmDir, `${id}.json`);
+
+  if (!existsSync(filepath)) {
+    throw new Error(`OdM ${id} introuvable.`);
+  }
+
+  const odm = JSON.parse(readFileSync(filepath, 'utf-8'));
+  odm.odm_meta.assigned_to = { actor_type: 'agent', actor_id: agentId };
+  odm.odm_meta.updated_at = new Date().toISOString();
+
+  const tmpPath = filepath + '.tmp';
+  writeFileSync(tmpPath, JSON.stringify(odm, null, 2) + '\n', 'utf-8');
+  renameSync(tmpPath, filepath);
+
+  return { id, assignedTo: agentId };
+}
+import { loadTemplate, mergeTemplate } from './templates.js';
+
+/**
+ * Init an OdM — creates a DRAFT ODM-*.json.
+ */
+export function initOdm(id, opts = {}) {
+  const {
+    title = '', assignedTo = '', priority = 'HAUTE',
+    root = process.cwd(), projectId = '',
+  } = opts;
+
+  const hcmDir = join(root, '.nemesis', 'HCM');
+  const odmDir = join(hcmDir, 'odm');
+
+  if (!existsSync(odmDir)) {
+    throw new Error('.nemesis/HCM/odm/ introuvable. Lancez "nemesis init" d\'abord.');
+  }
+
+  const template = loadTemplate('odm', root);
+  const odm = mergeTemplate(template, {
+    odm_meta: {
+      odm_id: id,
+      project_id: projectId,
+      status: 'DRAFT',
+      priority,
+      created_at: new Date().toISOString(),
+      created_by: { actor_type: 'human', actor_id: 'PM' },
+      assigned_to: assignedTo ? { actor_type: 'agent', actor_id: assignedTo } : { actor_type: '', actor_id: '' },
+    },
+    odm_payload: {
+      cadrage: { title },
+    },
+  });
+
+  const filepath = join(odmDir, `${id}.json`);
+  if (existsSync(filepath)) {
+    throw new Error(`OdM ${id} existe deja.`);
+  }
+
+  writeFileSync(filepath, JSON.stringify(odm, null, 2) + '\n', 'utf-8');
+  return { filepath, id, status: 'DRAFT' };
+}
+
+/**
+ * List all OdMs — ignores legacy_* files.
+ */
+export function listOdm(hcmDir) {
+  const odmDir = join(hcmDir, 'odm');
+  if (!existsSync(odmDir)) return [];
+
+  return readdirSync(odmDir)
+    .filter(f => f.endsWith('.json') && !f.startsWith('legacy_'))
+    .map(f => {
+      try {
+        const data = JSON.parse(readFileSync(join(odmDir, f), 'utf-8'));
+        return {
+          id: data.odm_meta?.odm_id || f.replace('.json', ''),
+          title: data.odm_payload?.cadrage?.title || '',
+          assignee: data.odm_meta?.assigned_to?.actor_id || '',
+          priority: data.odm_meta?.priority || '',
+          status: data.odm_meta?.status || 'UNKNOWN',
+        };
+      } catch (_e) {
+        /* fallback: malformed OdM */
+        return { id: f.replace('.json', ''), title: '', assignee: '', priority: '', status: 'ERROR' };
+      }
+    });
+}
+
+/**
+ * Inspect a specific OdM — full content + associated CRs.
+ */
+export function inspectOdm(id, hcmDir) {
+  const odmDir = join(hcmDir, 'odm');
+  const filepath = join(odmDir, `${id}.json`);
+
+  if (!existsSync(filepath)) {
+    throw new Error(`OdM ${id} introuvable.`);
+  }
+
+  const odm = JSON.parse(readFileSync(filepath, 'utf-8'));
+
+  // Find associated CRs
+  const crDir = join(hcmDir, 'cr');
+  let associatedCrs = [];
+  if (existsSync(crDir)) {
+    associatedCrs = readdirSync(crDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        try {
+          const data = JSON.parse(readFileSync(join(crDir, f), 'utf-8'));
+          return { file: f, data };
+        } catch (_e) {
+          /* fallback: malformed CR */
+          return null;
+        }
+      })
+      .filter(Boolean)
+      .filter(cr => {
+        const odmRef = cr.data.metadata?.odm_id || '';
+        return odmRef === id || cr.file.includes(id.replace('ODM-', ''));
+      })
+      .map(cr => ({
+        id: cr.data.metadata?.odm_id || cr.file,
+        title: cr.data.title || '',
+        status: cr.data.metadata?.status || 'UNKNOWN',
+        date: cr.data.metadata?.date_execution || '',
+      }));
+  }
+
+  return { odm, associatedCrs };
+}

package/lib/core/profile-picker.js

@@ -0,0 +1,323 @@
+import { interactiveMenu } from '../ui/menu.js';
+import { titledBox } from '../ui/box.js';
+import { style } from '../ui/colors.js';
+import { askText, askConfirm } from '../ui/prompt.js';
+import { createSpinner } from '../ui/spinner.js';
+import { debug } from './logger.js';
+
+/**
+ * Search profiles by sector via interactive picker.
+ * Returns selected profileId or null if cancelled.
+ * @param {object} client
+ * @param {function} write — UI output callback
+ */
+async function searchBySector(client, write) {
+  const spinner = createSpinner('Chargement des secteurs...');
+  spinner.start();
+
+  let profiles;
+  try {
+    // q is required by the API — use 'a' to match all profiles
+    const all = await client.searchProfiles('a');
+    profiles = Array.isArray(all) ? all : [];
+  } catch (e) {
+    debug(`searchBySector: ${e.message}`);
+    spinner.fail('Recherche indisponible');
+    return null;
+  }
+
+  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`);
+
+  if (sectors.length === 0) {
+    write(`  ${style.yellow('\u26A0')} Aucun secteur disponible.\n`);
+    return null;
+  }
+
+  const sector = await interactiveMenu(
+    sectors.map(s => ({ label: s, value: s })),
+    { title: 'Filtrer par secteur', maxVisible: 15 },
+  );
+  if (!sector) return null;
+
+  const sp2 = createSpinner(`Recherche secteur : ${sector}...`);
+  sp2.start();
+
+  try {
+    const results = await client.searchProfiles(null, sector);
+    const filtered = Array.isArray(results) ? results : [];
+    sp2.stop(`${filtered.length} profils`);
+
+    if (filtered.length === 0) {
+      write(`  Aucun profil pour le secteur "${sector}".\n`);
+      return null;
+    }
+
+    const items = filtered.map(p => ({
+      label: p.id,
+      value: p.id,
+      description: p.role || '',
+    }));
+
+    return interactiveMenu(items, {
+      title: `Profils — ${sector}`,
+      maxVisible: 10,
+    });
+  } catch (e) {
+    debug(`searchBySector filter: ${e.message}`);
+    sp2.fail('Erreur recherche');
+    return null;
+  }
+}
+
+/**
+ * Fetch profile list from HCM, enriched with role from NUCLEUS.
+ * Priority: /profiles/summary (1 request, id+role pre-joined).
+ * Fallback: listProfiles + fetchAllRoles (searchAtoms batch or per-profile).
+ * Returns sorted array of { id, role } or empty array.
+ */
+export async function fetchProfileList(client) {
+  // Fast path: /profiles/summary returns [{ id, role }] in 1 request
+  if (typeof client.listProfilesSummary === 'function') {
+    try {
+      const summary = await client.listProfilesSummary();
+      if (Array.isArray(summary) && summary.length > 0) {
+        return summary
+          .map(p => ({ id: p.id || '', role: p.role || '' }))
+          .filter(p => p.id)
+          .sort((a, b) => a.id.localeCompare(b.id, 'fr'));
+      }
+    } catch (e) {
+      debug(`fetchProfileList summary: ${e.message}`);
+    }
+  }
+
+  // Fallback: listProfiles + enrich with roles
+  const profiles = await client.listProfiles();
+  if (!Array.isArray(profiles) || profiles.length === 0) return [];
+
+  const list = profiles
+    .map(p => ({ id: p.label || p.profileId || p.id, role: '' }))
+    .filter(p => p.id)
+    .sort((a, b) => a.id.localeCompare(b.id, 'fr'));
+
+  try {
+    const roleMap = await fetchAllRoles(client);
+    for (const item of list) {
+      if (roleMap[item.id]) {
+        item.role = roleMap[item.id];
+      }
+    }
+  } catch (e) {
+    debug(`fetchProfileList roles: ${e.message}`);
+  }
+
+  return list;
+}
+
+/**
+ * Fetch all NUCLEUS role atoms in one call, return { profileId → shortRole } map.
+ */
+async function fetchAllRoles(client) {
+  const map = {};
+
+  // Try batch searchAtoms first (1 call)
+  if (typeof client.searchAtoms === 'function') {
+    try {
+      const atoms = await client.searchAtoms({ sousFamille: 'NUCLEUS', type: 'role', limit: 200 });
+      for (const a of atoms) {
+        const profileId = a.famille || a.profileId || '';
+        const occ = a.occurrence || a.node?.data?.occurrence || a.data?.occurrence || '';
+        if (profileId && occ) {
+          map[profileId] = occ.split(' \u2014 ')[0] || occ;
+        }
+      }
+      if (Object.keys(map).length > 0) return map;
+    } catch (e) {
+      debug(`fetchAllRoles searchAtoms: ${e.message}`);
+    }
+  }
+
+  // Fallback: per-profile fetch, 5 at a time max
+  if (typeof client.getProfileAtoms === 'function') {
+    try {
+      const profiles = await client.listProfiles();
+      const ids = (Array.isArray(profiles) ? profiles : [])
+        .map(p => p.label || p.profileId || p.id)
+        .filter(Boolean);
+
+      const BATCH = 5;
+      for (let i = 0; i < ids.length; i += BATCH) {
+        const batch = ids.slice(i, i + BATCH);
+        const results = await Promise.allSettled(
+          batch.map(id => client.getProfileAtoms(id, ['NUCLEUS']).catch(() => []))
+        );
+        for (let j = 0; j < batch.length; j++) {
+          if (results[j].status === 'fulfilled') {
+            const atoms = results[j].value;
+            const items = Array.isArray(atoms) ? atoms : (atoms?.atoms || []);
+            const nucleus = extractNucleus(items);
+            if (nucleus.role) {
+              map[batch[j]] = nucleus.role.split(' \u2014 ')[0] || nucleus.role;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      debug(`fetchAllRoles per-profile: ${e.message}`);
+    }
+  }
+
+  return map;
+}
+
+/**
+ * Fetch NUCLEUS atoms for a single profile (role, mission, mindset).
+ * Returns { role, mission, mindset } or null.
+ */
+export async function fetchProfileDetail(client, profileId) {
+  try {
+    const atoms = await client.getProfileAtoms(profileId, ['NUCLEUS']);
+    const items = Array.isArray(atoms) ? atoms : (atoms?.atoms || []);
+    return extractNucleus(items);
+  } catch (e) {
+    debug(`fetchProfileDetail ${profileId}: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Extract role/mission/mindset from NUCLEUS atoms array.
+ */
+export function extractNucleus(atoms) {
+  const get = (label) => {
+    const atom = atoms.find(a =>
+      (a.node?.label || a.label || '').toLowerCase() === label
+    );
+    return atom?.node?.data?.occurrence || atom?.data?.occurrence || '';
+  };
+  return {
+    role: get('role'),
+    mission: get('mission'),
+    mindset: get('mindset'),
+  };
+}
+
+/**
+ * Render a profile confirmation box using titledBox.
+ * Returns the formatted string.
+ */
+export function renderProfileConfirmation(profileId, detail) {
+  const lines = [];
+  if (detail.role) {
+    lines.push(`${style.bold('Role')}     ${detail.role}`);
+  }
+  if (detail.mission) {
+    lines.push('');
+    lines.push(`${style.bold('Mission')}  ${detail.mission}`);
+  }
+  if (detail.mindset) {
+    lines.push('');
+    lines.push(`${style.bold('Mindset')}  ${style.dim(detail.mindset)}`);
+  }
+  return titledBox(`Profil : ${profileId}`, lines, {
+    border: style.nemesisAccent,
+    padding: 1,
+  });
+}
+
+/**
+ * Full interactive profile picker: list → select → confirm → return profileId.
+ * @param {object} client — HCM client
+ * @param {{ write?: function }} [opts] — write callback for UI output (default: no-op)
+ * @returns {Promise<{ id: string, kairosData: object|null }>}
+ */
+export async function pickProfile(client, { write = () => {} } = {}) {
+  let profileItems = [{ label: style.dim('(saisie manuelle)'), value: '__custom__' }];
+  let hcmConnected = false;
+
+  const spinner = createSpinner('Chargement des profils Kairos...');
+  spinner.start();
+
+  try {
+    const profiles = await fetchProfileList(client);
+    hcmConnected = true;
+    spinner.stop(`${profiles.length} profils charges`);
+    if (profiles.length > 0) {
+      profileItems = [
+        { label: style.nemesisAccent('(rechercher par secteur)'), value: '__search__' },
+        ...profiles.map(p => ({
+          label: p.id,
+          value: p.id,
+          description: p.role || '',
+        })),
+        { label: style.dim('(saisie manuelle)'), value: '__custom__' },
+      ];
+    } else {
+      write(`  ${style.yellow('\u26A0')} HCM connecte mais aucun profil Kairos disponible.\n`);
+    }
+  } catch (err) {
+    spinner.fail('HCM non connecte');
+    write(`\n  ${style.yellow('\u26A0')} HCM non connecte \u2014 saisie manuelle du profil.`);
+    write(`  ${style.dim('\u2192')} ${style.dim(err.message || String(err))}`);
+    write(`  ${style.dim('\u2192 Configurez avec')} nemesis auth login\n`);
+  }
+
+  // Selection loop — allows retry on confirmation decline
+  while (true) {
+    const profileCount = profileItems.filter(p => p.value !== '__custom__').length;
+    const titleSuffix = hcmConnected && profileCount > 0 ? ` (${profileCount} profils HCM)` : '';
+    const selected = await interactiveMenu(profileItems, {
+      title: `Profil Kairos${titleSuffix}`,
+      maxVisible: 10,
+    });
+
+    if (selected === '__search__') {
+      const found = await searchBySector(client, write);
+      if (found) {
+        const spinner2 = createSpinner('Chargement du profil...');
+        spinner2.start();
+        const detail = await fetchProfileDetail(client, found);
+        spinner2.stop(found);
+        if (detail && (detail.role || detail.mission)) {
+          write('');
+          write(renderProfileConfirmation(found, detail));
+          const confirmed = await askConfirm('Confirmer ce profil ?', true);
+          if (confirmed) return { id: found, kairosData: detail };
+        } else {
+          return { id: found, kairosData: null };
+        }
+      }
+      continue;
+    }
+
+    if (selected === '__custom__' || selected === null) {
+      const customId = await askText('Profil Kairos ID (optionnel)', '');
+      return { id: customId, kairosData: null };
+    }
+
+    // Confirmation screen — fetch NUCLEUS for the selected profile only
+    if (hcmConnected) {
+      const spinner3 = createSpinner('Chargement du profil...');
+      spinner3.start();
+      const detail = await fetchProfileDetail(client, selected);
+      spinner3.stop(selected);
+      if (detail && (detail.role || detail.mission)) {
+        write('');
+        write(renderProfileConfirmation(selected, detail));
+        const confirmed = await askConfirm('Confirmer ce profil ?', true);
+        if (confirmed) return { id: selected, kairosData: detail };
+        continue;
+      }
+    }
+
+    return { id: selected, kairosData: null };
+  }
+}