@arka-labs/nemesis 1.2.0

package/lib/core/agent-launcher.js

@@ -0,0 +1,193 @@
+/**
+ * Agent launcher — spawn Claude CLI with streaming JSON output.
+ * Two exports:
+ *   launchAgent(promptPath, opts) — low-level spawn + stream parse
+ *   runOnboarding(promptPath, agentName) — high-level with UI (spinner + streambox)
+ */
+
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createSpinner } from '../ui/spinner.js';
+import { createStreamBox } from '../ui/streambox.js';
+import { titledBox } from '../ui/box.js';
+import { style } from '../ui/colors.js';
+
+/**
+ * Launch Claude with a prompt file, parse stream-json output.
+ * Pipes prompt via stdin to avoid OS arg-length limits.
+ * @param {string} promptPath — absolute path to the prompt .md file
+ * @param {object} opts
+ * @param {function} [opts.onLine] — called with each assistant text chunk
+ * @param {number}   [opts.timeout] — ms before SIGTERM (default 120_000)
+ * @returns {Promise<{ sessionId: string|null, finalMessage: string, exitCode: number, stderrOutput: string, pid: number|null }>}
+ */
+export function launchAgent(promptPath, opts = {}) {
+  const { onLine = () => {}, timeout = 120_000 } = opts;
+
+  return new Promise((resolve, reject) => {
+    let promptContent;
+    try {
+      promptContent = readFileSync(promptPath, 'utf-8');
+    } catch (_e) {
+      return reject(new Error(`Impossible de lire le prompt : ${promptPath}`));
+    }
+
+    let child;
+    try {
+      child = spawn('claude', [
+        '-p', promptContent,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--dangerously-skip-permissions',
+      ], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: (() => { const e = { ...process.env }; delete e.CLAUDECODE; return e; })(),
+      });
+    } catch (_e) {
+      return reject(new Error('Impossible de lancer claude. Verifiez que Claude CLI est installe.'));
+    }
+
+    let sessionId = null;
+    let finalMessage = '';
+    let lineBuffer = '';
+    let stderrOutput = '';
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      if (!settled) {
+        settled = true;
+        reject(new Error(`Timeout : l'agent n'a pas repondu en ${timeout / 1000}s`));
+      }
+    }, timeout);
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      if (err.code === 'ENOENT') {
+        reject(new Error('Claude CLI introuvable. Installez-le avec : npm i -g @anthropic-ai/claude-code'));
+      } else {
+        reject(err);
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderrOutput += chunk.toString();
+    });
+
+    child.stdout.on('data', (chunk) => {
+      lineBuffer += chunk.toString();
+      const lines = lineBuffer.split('\n');
+      lineBuffer = lines.pop(); // keep incomplete last line
+
+      for (const raw of lines) {
+        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) {
+                const textLines = block.text.split('\n').filter(Boolean);
+                for (const tl of textLines) onLine(tl);
+              }
+            }
+          }
+          if (evt.type === 'result') {
+            sessionId = evt.session_id || null;
+            finalMessage = evt.result || '';
+          }
+        } catch (_e) {
+          /* fallback: non-JSON stream line */
+          onLine(raw.trim());
+        }
+      }
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      resolve({ sessionId, finalMessage, exitCode: code ?? 1, stderrOutput, pid: child.pid ?? null });
+    });
+  });
+}
+
+/**
+ * High-level onboarding: spinner + streambox(4) + build display box.
+ * Returns result data + displayBox string for the caller to print.
+ * @param {string} promptPath
+ * @param {string} agentName
+ * @returns {Promise<{ sessionId: string|null, finalMessage: string, exitCode: number, stderrOutput: string, pid: number|null, displayBox: string }>}
+ */
+export async function runOnboarding(promptPath, agentName) {
+  const spinner = createSpinner(`Onboarding ${style.bold(agentName)}...`);
+  const box = createStreamBox(4);
+
+  spinner.start();
+  process.stdout.write('\n');
+
+  let result;
+  try {
+    result = await launchAgent(promptPath, {
+      onLine(line) {
+        box.push(style.dim(line));
+      },
+    });
+  } catch (err) {
+    box.clear();
+    spinner.fail(err.message);
+
+    const fallbackLines = [
+      `${style.red('Onboarding automatique echoue')} : ${err.message}`,
+      '',
+      'Lancez manuellement :',
+      `  ${style.bold(`cat "${promptPath}" | claude -p -`)}`,
+    ];
+    const displayBox = titledBox('Fallback', fallbackLines, { border: style.yellow });
+
+    return { sessionId: null, finalMessage: err.message, exitCode: 1, stderrOutput: '', pid: null, displayBox };
+  }
+
+  box.clear();
+
+  const success = result.exitCode === 0;
+  if (success) {
+    spinner.stop(`Onboarding ${style.bold(agentName)} termine`);
+  } else {
+    spinner.fail(`Onboarding ${style.bold(agentName)} — exit code ${result.exitCode}`);
+  }
+
+  const resultLines = [];
+
+  if (result.finalMessage) {
+    resultLines.push(...result.finalMessage.split('\n'));
+  } else if (result.stderrOutput) {
+    resultLines.push(style.red('stderr:'));
+    resultLines.push(...result.stderrOutput.split('\n').slice(0, 5));
+  } else if (!success) {
+    resultLines.push(`Le processus s'est termine avec le code ${result.exitCode}`);
+  }
+
+  if (result.sessionId) {
+    resultLines.push('');
+    resultLines.push(`${style.bold('Session')} : ${style.nemesisAccent(result.sessionId)}`);
+    resultLines.push('');
+    resultLines.push(`Reprendre la session : ${style.bold(`nemesis run agent:${agentName}`)}`);
+    resultLines.push(`Envoyer un prompt    : ${style.bold(`nemesis run agent:${agentName} --p "votre instruction"`)}`);
+  }
+
+  if (resultLines.length === 0) {
+    resultLines.push(`Onboarding termine (exit ${result.exitCode})`);
+    resultLines.push(`Pas de session capturee.`);
+    resultLines.push('');
+    resultLines.push('Lancez manuellement :');
+    resultLines.push(`  ${style.bold(`cat "${promptPath}" | claude -p -`)}`);
+  }
+
+  const boxTitle = result.sessionId ? 'Reponse agent' : 'Resultat onboarding';
+  const boxBorder = success ? style.nemesisAccent : style.yellow;
+  const displayBox = titledBox(boxTitle, resultLines, { border: boxBorder });
+
+  return { ...result, displayBox };
+}

package/lib/core/audit.js

@@ -0,0 +1,210 @@
+/**
+ * Audit module — load templates, build prompts, save reports.
+ * Templates are JSON files in .nemesis/HCM/audit/ (or legacy .owner/HCM/audit/).
+ */
+
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Resolve the audit directory for a project.
+ * Priority: hcm_dir/audit/, fallback: .owner/HCM/audit/ (legacy).
+ */
+function resolveAuditDir(project) {
+  const primary = join(project.hcm_dir, 'audit');
+  if (existsSync(primary) && readdirSync(primary).some(f => f.endsWith('.json'))) {
+    return primary;
+  }
+  // Legacy fallback
+  const legacy = join(project.root, '.owner', 'HCM', 'audit');
+  if (existsSync(legacy)) return legacy;
+  return primary; // default even if empty
+}
+
+/**
+ * Scan audit directory for template JSON files.
+ * Returns array of { id, name, description, path }.
+ */
+export function loadAuditTemplates(project) {
+  const auditDir = resolveAuditDir(project);
+  if (!existsSync(auditDir)) return [];
+
+  const files = readdirSync(auditDir).filter(f => f.endsWith('.json'));
+  const templates = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(readFileSync(join(auditDir, file), 'utf-8'));
+      if (data.audit_meta?.audit_type_id) {
+        templates.push({
+          id: data.audit_meta.audit_type_id,
+          name: data.audit_meta.name || data.audit_meta.audit_type_id,
+          description: data.audit_meta.description || '',
+          path: join(auditDir, file),
+        });
+      }
+    } catch (_e) { /* fallback: skip malformed audit JSON */ }
+  }
+
+  return templates.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/**
+ * Load a single audit template by ID.
+ * Returns the full parsed JSON or null if not found.
+ */
+export function loadTemplate(project, templateId) {
+  const templates = loadAuditTemplates(project);
+  const entry = templates.find(t => t.id === templateId);
+  if (!entry) return null;
+  return JSON.parse(readFileSync(entry.path, 'utf-8'));
+}
+
+/**
+ * Build a complete LLM prompt from an audit template and target definition.
+ * @param {object} template — parsed audit template JSON
+ * @param {object} cible — { type, path, nom, contexte, taille_equipe, stack }
+ * @returns {string} markdown prompt ready for LLM
+ */
+export function buildAuditPrompt(template, cible) {
+  const meta = template.audit_meta;
+  const methodo = template.methodologie;
+  const output = template.output;
+
+  const lines = [];
+
+  // Header
+  lines.push(`# ${meta.name}`);
+  lines.push('');
+
+  // Persona & posture
+  lines.push(`## Persona`);
+  lines.push(meta.persona);
+  lines.push('');
+  lines.push(`## Posture`);
+  lines.push(meta.posture);
+  lines.push('');
+
+  // Target
+  lines.push('## Cible');
+  lines.push('');
+  if (cible.nom) lines.push(`- **Nom** : ${cible.nom}`);
+  if (cible.type) lines.push(`- **Type** : ${cible.type}`);
+  if (cible.path) lines.push(`- **Path** : ${cible.path}`);
+  if (cible.contexte) lines.push(`- **Contexte** : ${cible.contexte}`);
+  if (cible.taille_equipe) lines.push(`- **Taille equipe** : ${cible.taille_equipe}`);
+  if (cible.stack) lines.push(`- **Stack** : ${cible.stack}`);
+  lines.push('');
+
+  // Methodology
+  if (methodo?.analyse_domains) {
+    lines.push('## Methodologie');
+    lines.push('');
+    for (const domain of methodo.analyse_domains) {
+      lines.push(`### ${domain.titre}`);
+      const items = domain.points || domain.criteres || domain.inspections || domain.principes || domain.risques || [];
+      for (const item of items) {
+        lines.push(`- ${item}`);
+      }
+      if (domain.verifications) {
+        lines.push('');
+        lines.push('**Verifications :**');
+        for (const v of domain.verifications) {
+          lines.push(`- ${v}`);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  // Imperative rules
+  if (methodo?.regles_imperatives) {
+    lines.push('## Regles imperatives');
+    lines.push('');
+    for (const r of methodo.regles_imperatives) {
+      lines.push(`- ${r}`);
+    }
+    lines.push('');
+  }
+
+  // Style
+  if (methodo?.style) {
+    lines.push('## Style attendu');
+    lines.push('');
+    for (const s of methodo.style) {
+      lines.push(`- ${s}`);
+    }
+    lines.push('');
+  }
+
+  // Output format
+  if (output?.sections) {
+    lines.push('## Format de sortie attendu');
+    lines.push('');
+    lines.push(`Format : ${output.format || 'markdown'}`);
+    lines.push('');
+    lines.push('Sections attendues :');
+    for (const section of output.sections) {
+      lines.push(`1. **${section.titre}**`);
+      if (section.contenu) {
+        for (const c of section.contenu) {
+          lines.push(`   - ${c}`);
+        }
+      }
+      if (section.scoring?.dimensions) {
+        lines.push(`   Dimensions (echelle ${section.scoring.echelle}) :`);
+        for (const d of section.scoring.dimensions) {
+          lines.push(`   - ${d}`);
+        }
+      }
+      if (section.par_domaine?.domaines) {
+        lines.push(`   Domaines : ${section.par_domaine.domaines.join(', ')}`);
+        lines.push(`   Structure : ${section.par_domaine.structure_champ.join(' | ')}`);
+      }
+      if (section.categories) {
+        lines.push(`   Categories : ${section.categories.join(', ')}`);
+      }
+      if (section.horizons) {
+        for (const h of section.horizons) {
+          lines.push(`   - ${h.label} (${h.delai})`);
+        }
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Save an audit report to .nemesis/HCM/audit/reports/.
+ * @param {object} project
+ * @param {string} auditId — e.g. "AUDIT-TECHNIQUE"
+ * @param {string} content — markdown content
+ * @returns {string} path to saved report
+ */
+export function saveReport(project, auditId, content) {
+  const reportsDir = join(project.hcm_dir, 'audit', 'reports');
+  mkdirSync(reportsDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const filename = `${auditId}_${timestamp}.md`;
+  const filepath = join(reportsDir, filename);
+  writeFileSync(filepath, content, 'utf-8');
+  return filepath;
+}
+
+/**
+ * List existing audit reports.
+ * Returns array of { filename, path }.
+ */
+export function listReports(project) {
+  const reportsDir = join(project.hcm_dir, 'audit', 'reports');
+  if (!existsSync(reportsDir)) return [];
+
+  return readdirSync(reportsDir)
+    .filter(f => f.endsWith('.md'))
+    .sort()
+    .reverse()
+    .map(f => ({ filename: f, path: join(reportsDir, f) }));
+}

package/lib/core/connexions.js

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { storeSecret, getSecret, removeSecret } from './secrets.js';
+
+const CONNEXIONS_FILE = join(homedir(), '.nemesis', 'connexions.json');
+
+export const PROVIDERS = [
+  { id: 'anthropic',    label: 'Anthropic',    authTypes: ['api_key'] },
+  { id: 'openai',       label: 'OpenAI',       authTypes: ['api_key'] },
+  { id: 'google_cloud', label: 'Google Cloud', authTypes: ['api_key', 'token'] },
+  { id: 'gemini_genai', label: 'Gemini GenAI', authTypes: ['api_key'] },
+  { id: 'aws_bedrock',  label: 'AWS Bedrock',  authTypes: ['api_key'] },
+  { id: 'ollama',       label: 'Ollama',       authTypes: ['none'] },
+  { id: 'groq',         label: 'Groq',         authTypes: ['api_key'] },
+  { id: 'custom',       label: 'Custom',       authTypes: ['api_key', 'token'] },
+  { id: 'cli_tools',    label: 'CLI Tools',    authTypes: ['none'] },
+];
+
+export function readConnexions() {
+  if (!existsSync(CONNEXIONS_FILE)) return { connexions: [] };
+  try { return JSON.parse(readFileSync(CONNEXIONS_FILE, 'utf-8')); }
+  catch (_e) { /* fallback: corrupted connexions file */ return { connexions: [] }; }
+}
+
+export function writeConnexions(data) {
+  const dir = join(homedir(), '.nemesis');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(CONNEXIONS_FILE, JSON.stringify(data, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+}
+
+export function addConnexion({ name, provider, authType, model, credential, endpoint, cliArgs }) {
+  const data = readConnexions();
+  const id = randomUUID();
+  const now = new Date().toISOString();
+  const connexion = {
+    id, name, provider, auth_type: authType,
+    model: model || null, endpoint: endpoint || null,
+    cli_args: cliArgs || null,
+    status: 'untested', last_tested: null, created_at: now,
+  };
+  data.connexions.push(connexion);
+  writeConnexions(data);
+  if (credential) storeSecret(id, credential);
+  return connexion;
+}
+
+export function getConnexion(id) {
+  return readConnexions().connexions.find(c => c.id === id) || null;
+}
+
+export function listConnexions() {
+  return readConnexions().connexions;
+}
+
+export function updateConnexionStatus(id, status, latency) {
+  const data = readConnexions();
+  const cx = data.connexions.find(c => c.id === id);
+  if (!cx) return false;
+  cx.status = status;
+  cx.last_tested = new Date().toISOString();
+  if (latency !== undefined) cx.latency = latency;
+  writeConnexions(data);
+  return true;
+}
+
+export function removeConnexion(id) {
+  const data = readConnexions();
+  const idx = data.connexions.findIndex(c => c.id === id);
+  if (idx === -1) return false;
+  data.connexions.splice(idx, 1);
+  writeConnexions(data);
+  removeSecret(id);
+  return true;
+}
+
+export function getConnexionCredential(id) {
+  return getSecret(id);
+}

package/lib/core/flowmap/api.js

@@ -0,0 +1,111 @@
+import { createActor } from 'xstate';
+import { flowmapMachine } from './machine.js';
+import { saveSnapshot, loadSnapshot, listSnapshots } from './persistence.js';
+
+/**
+ * Create (or restore) a FLOWMAP actor for a mission.
+ * Auto-persists snapshots on every transition via subscribe.
+ *
+ * @param {string} missionId
+ * @param {object} [opts]
+ * @param {string} [opts.root] - project root (default: cwd)
+ * @param {string} [opts.odmId]
+ * @param {string} [opts.projectId]
+ * @param {object} [opts.metadata]
+ * @returns {{ actor, snapshot }}
+ */
+export function createFlowmapActor(missionId, opts = {}) {
+  const { root = process.cwd(), odmId, projectId, metadata } = opts;
+
+  const existing = loadSnapshot(root, missionId);
+
+  const actor = createActor(flowmapMachine, {
+    input: { missionId, odmId, projectId, metadata },
+    ...(existing ? { snapshot: existing } : {}),
+  });
+
+  // Auto-persist on every transition
+  actor.subscribe((_snapshot) => {
+    saveSnapshot(root, missionId, actor.getPersistedSnapshot());
+  });
+
+  actor.start();
+
+  return { actor, snapshot: actor.getSnapshot() };
+}
+
+/**
+ * One-shot: create actor, send event, stop, return state.
+ * Adapted for CLI usage — no long-running actors.
+ *
+ * @param {string} missionId
+ * @param {{ type: string, [key: string]: any }} event
+ * @param {object} [opts]
+ * @returns {{ value, context }}
+ */
+export function sendFlowmapEvent(missionId, event, opts = {}) {
+  const { actor } = createFlowmapActor(missionId, opts);
+
+  actor.send(event);
+  const snapshot = actor.getSnapshot();
+  actor.stop();
+
+  return {
+    value: snapshot.value,
+    context: snapshot.context,
+  };
+}
+
+/**
+ * Read-only: get the current state of a mission.
+ * Returns null if no snapshot exists.
+ *
+ * @param {string} missionId
+ * @param {object} [opts]
+ * @returns {{ value, context } | null}
+ */
+export function getCurrentState(missionId, opts = {}) {
+  const { root = process.cwd() } = opts;
+
+  const existing = loadSnapshot(root, missionId);
+  if (!existing) return null;
+
+  const actor = createActor(flowmapMachine, {
+    input: { missionId },
+    snapshot: existing,
+  });
+  actor.start();
+
+  const snapshot = actor.getSnapshot();
+  actor.stop();
+
+  return {
+    value: snapshot.value,
+    context: snapshot.context,
+  };
+}
+
+/**
+ * Get the transition history of a mission.
+ * Returns empty array if no snapshot exists.
+ *
+ * @param {string} missionId
+ * @param {object} [opts]
+ * @returns {Array}
+ */
+export function getStateHistory(missionId, opts = {}) {
+  const state = getCurrentState(missionId, opts);
+  if (!state) return [];
+  return state.context.history;
+}
+
+/**
+ * List all missions that have a persisted state snapshot.
+ *
+ * @param {object} [opts]
+ * @returns {string[]}
+ */
+export function listActiveMissions(opts = {}) {
+  const { root = process.cwd() } = opts;
+  return listSnapshots(root);
+}

package/lib/core/flowmap/cli-helpers.js

@@ -0,0 +1,80 @@
+/**
+ * cli-helpers.js — Pure functions for FLOWMAP display in CLI commands.
+ * Extracted for testability and reuse across status, project, odm, mission.
+ */
+
+import { getCurrentState, getStateHistory, listActiveMissions } from './api.js';
+import { STEP_METADATA } from './machine.js';
+
+/**
+ * Get a summary of all active missions with their FLOWMAP state.
+ *
+ * @param {string} root - project root
+ * @returns {Array<{ missionId: string, state: string, phase: string, who: string, label: string }>}
+ */
+export function getFlowmapSummary(root) {
+  const missionIds = listActiveMissions({ root });
+  const results = [];
+
+  for (const missionId of missionIds) {
+    const current = getCurrentState(missionId, { root });
+    if (!current) continue;
+
+    const meta = STEP_METADATA[current.value];
+    if (!meta) continue;
+
+    results.push({
+      missionId,
+      state: current.value,
+      phase: meta.phase,
+      who: meta.who,
+      label: meta.label,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Get the FLOWMAP phase for an OdM based on its mission_id.
+ *
+ * @param {object} odmMeta - odm.odm_meta object
+ * @param {string} root - project root
+ * @returns {string|null} - phase string or null
+ */
+export function getOdmFlowmapPhase(odmMeta, root) {
+  if (!odmMeta || !odmMeta.mission_id) return null;
+
+  const current = getCurrentState(odmMeta.mission_id, { root });
+  if (!current) return null;
+
+  const meta = STEP_METADATA[current.value];
+  return meta ? meta.phase : null;
+}
+
+/**
+ * Get full FLOWMAP info for a specific mission.
+ *
+ * @param {string} missionId
+ * @param {string} root - project root
+ * @returns {{ state: string, phase: string, who: string, label: string, history: Array } | null}
+ */
+export function getMissionFlowmapInfo(missionId, root) {
+  if (!missionId) return null;
+
+  const current = getCurrentState(missionId, { root });
+  if (!current) return null;
+
+  const meta = STEP_METADATA[current.value];
+  if (!meta) return null;
+
+  const history = getStateHistory(missionId, { root });
+
+  return {
+    state: current.value,
+    phase: meta.phase,
+    who: meta.who,
+    label: meta.label,
+    history,
+  };
+}