@arka-labs/nemesis 1.2.0

package/lib/kairos/claude-invoker.js

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { ALL_HOOKS, getHookStatus } from './hook-installer.js';
+import { generateActivationPrompt, generateDeactivationPrompt } from './hook-prompts.js';
+
+/**
+ * Invoke `claude -p` with a prompt and capture stdout.
+ * Uses spawnSync to avoid hanging on inherited stdio pipes.
+ * @param {string} prompt
+ * @param {object} options - { cwd, timeout }
+ * @returns {{ ok: boolean, output?: string, error?: string }}
+ */
+export function invokeClaudeP(prompt, options = {}) {
+  const bin = process.env.CLAUDE_BIN || 'claude';
+  const timeout = options.timeout || 60000;
+
+  try {
+    const result = spawnSync(bin, ['-p', prompt, '--dangerously-skip-permissions'], {
+      cwd: options.cwd || process.cwd(),
+      timeout,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    if (result.error) {
+      if (result.error.code === 'ENOENT') {
+        return { ok: false, error: 'claude CLI introuvable' };
+      }
+      if (result.error.code === 'ETIMEDOUT') {
+        return { ok: false, error: `Timeout (${timeout}ms)` };
+      }
+      return { ok: false, error: result.error.message };
+    }
+
+    if (result.status !== 0) {
+      return { ok: false, error: result.stderr || `Exit code ${result.status}` };
+    }
+
+    return { ok: true, output: result.stdout };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Activate a hook via claude -p.
+ * @param {string} projectRoot
+ * @param {string} hookEvent - e.g. 'SessionStart'
+ * @returns {{ ok: boolean, verified: boolean, error?: string }}
+ */
+export function activateHook(projectRoot, hookEvent) {
+  const meta = ALL_HOOKS[hookEvent];
+  if (!meta) return { ok: false, verified: false, error: `Hook inconnu: ${hookEvent}` };
+
+  const prompt = generateActivationPrompt(hookEvent, meta.command);
+  const result = invokeClaudeP(prompt, { cwd: projectRoot });
+
+  if (!result.ok) {
+    return { ok: false, verified: false, error: result.error };
+  }
+
+  const confirmed = (result.output || '').includes('HOOK_ACTIVATED_OK');
+  const status = getHookStatus(projectRoot);
+  const verified = status[hookEvent]?.active || false;
+
+  return { ok: confirmed || verified, verified, error: confirmed ? null : 'Confirmation absente dans la reponse' };
+}
+
+/**
+ * Deactivate a hook via claude -p.
+ * @param {string} projectRoot
+ * @param {string} hookEvent - e.g. 'SessionStart'
+ * @returns {{ ok: boolean, verified: boolean, error?: string }}
+ */
+export function deactivateHook(projectRoot, hookEvent) {
+  const meta = ALL_HOOKS[hookEvent];
+  if (!meta) return { ok: false, verified: false, error: `Hook inconnu: ${hookEvent}` };
+
+  const prompt = generateDeactivationPrompt(hookEvent, meta.command);
+  const result = invokeClaudeP(prompt, { cwd: projectRoot });
+
+  if (!result.ok) {
+    return { ok: false, verified: false, error: result.error };
+  }
+
+  const confirmed = (result.output || '').includes('HOOK_DEACTIVATED_OK');
+  const status = getHookStatus(projectRoot);
+  const verified = !status[hookEvent]?.active;
+
+  return { ok: confirmed || verified, verified, error: confirmed ? null : 'Confirmation absente dans la reponse' };
+}

package/lib/kairos/context-injector.js

@@ -0,0 +1,331 @@
+/**
+ * Context Injector — unified context builder for SessionStart / PreCompact / situational updates.
+ *
+ * Single canal (stdout), driven by situation via client.navigate(), zero duplication.
+ *
+ * Leader receives: B00 (gouvernance) + situational bloc + dispatch/validation ops + recent memory
+ * Expert receives: B00 (gouvernance) + situational bloc + recent memory
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  LEADER_DISPATCH,
+  LEADER_VALIDATION,
+  LEADER_INTERDICTIONS,
+} from './leader-rules.js';
+import { debug } from '../core/logger.js';
+
+/**
+ * Get recent notes for an agent, sorted by mtime desc.
+ *
+ * @param {string} root - project root
+ * @param {string} agentName - e.g. "Agent_Leader_-_Architecte"
+ * @param {number} [limit=2] - max notes to return
+ * @returns {Array<{ id: string, content: string, timestamp: string }>}
+ */
+export function getRecentNotes(root, agentName, limit = 2) {
+  const notesBase = join(root, '.nemesis', 'claude', agentName, 'notes');
+  if (!existsSync(notesBase)) return [];
+
+  const allFiles = [];
+  try {
+    const months = readdirSync(notesBase).filter(d => /^\d{4}-\d{2}$/.test(d));
+    for (const month of months) {
+      const monthDir = join(notesBase, month);
+      const files = readdirSync(monthDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        const filepath = join(monthDir, file);
+        allFiles.push({ filepath, mtime: statSync(filepath).mtimeMs });
+      }
+    }
+  } catch (e) { debug(`getRecentNotes scan: ${e.message}`); return []; }
+
+  allFiles.sort((a, b) => b.mtime - a.mtime);
+
+  const result = [];
+  for (const { filepath } of allFiles.slice(0, limit)) {
+    try {
+      const data = JSON.parse(readFileSync(filepath, 'utf-8'));
+      result.push({
+        id: data.id || '',
+        content: data.content || data.inputSummary || '',
+        timestamp: data.timestamp || '',
+      });
+    } catch (e) { debug(`getRecentNotes parse: ${e.message}`); }
+  }
+  return result;
+}
+
+/**
+ * Get recent CRs for an agent, sorted by mtime desc.
+ *
+ * @param {string} root - project root
+ * @param {string} agentName
+ * @param {number} [limit=1] - max CRs to return
+ * @returns {Array<{ id: string, summary: string, timestamp: string }>}
+ */
+export function getRecentCRs(root, agentName, limit = 1) {
+  const crDir = join(root, '.nemesis', 'claude', agentName, 'cr');
+  if (!existsSync(crDir)) return [];
+
+  const allFiles = [];
+  try {
+    const files = readdirSync(crDir).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const filepath = join(crDir, file);
+      allFiles.push({ filepath, mtime: statSync(filepath).mtimeMs });
+    }
+  } catch (e) { debug(`getRecentCRs scan: ${e.message}`); return []; }
+
+  allFiles.sort((a, b) => b.mtime - a.mtime);
+
+  const result = [];
+  for (const { filepath } of allFiles.slice(0, limit)) {
+    try {
+      const data = JSON.parse(readFileSync(filepath, 'utf-8'));
+      result.push({
+        id: data.id || '',
+        summary: data.content?.summary || data.summary || '',
+        timestamp: data.metadata?.date_execution || data.timestamp || data.period?.to || data.period?.from || '',
+      });
+    } catch (e) { debug(`getRecentCRs parse: ${e.message}`); }
+  }
+  return result;
+}
+
+/**
+ * Get recent memory summary (notes + CRs) formatted as markdown.
+ *
+ * @param {string} root - project root
+ * @param {string} agentName
+ * @param {'leader'|'expert'} role
+ * @param {string} [leaderName] - leader name (for expert role)
+ * @returns {string}
+ */
+export function getRecentMemory(root, agentName, role, leaderName) {
+  const lines = [];
+
+  if (role === 'leader') {
+    // Own last CR
+    const crs = getRecentCRs(root, agentName, 1);
+    if (crs.length > 0) {
+      lines.push('## Dernier CR', '');
+      for (const cr of crs) {
+        lines.push(`**${cr.id}** (${cr.timestamp})`);
+        if (cr.summary) lines.push(cr.summary);
+        lines.push('');
+      }
+    }
+
+    // Own 2 last notes
+    const notes = getRecentNotes(root, agentName, 2);
+    if (notes.length > 0) {
+      lines.push('## Notes recentes', '');
+      for (const note of notes) {
+        lines.push(`**${note.id}** (${note.timestamp})`);
+        if (note.content) lines.push(note.content);
+        lines.push('');
+      }
+    }
+  } else {
+    // Expert: Leader's last CR
+    if (leaderName) {
+      const leaderCrs = getRecentCRs(root, leaderName, 1);
+      if (leaderCrs.length > 0) {
+        lines.push('## Dernier CR du Leader', '');
+        for (const cr of leaderCrs) {
+          lines.push(`**${cr.id}** (${cr.timestamp})`);
+          if (cr.summary) lines.push(cr.summary);
+          lines.push('');
+        }
+      }
+    }
+
+    // Own 2 last CRs
+    const ownCrs = getRecentCRs(root, agentName, 2);
+    if (ownCrs.length > 0) {
+      lines.push('## Mes derniers CR', '');
+      for (const cr of ownCrs) {
+        lines.push(`**${cr.id}** (${cr.timestamp})`);
+        if (cr.summary) lines.push(cr.summary);
+        lines.push('');
+      }
+    }
+
+    // Own 2 last notes
+    const notes = getRecentNotes(root, agentName, 2);
+    if (notes.length > 0) {
+      lines.push('## Notes recentes', '');
+      for (const note of notes) {
+        lines.push(`**${note.id}** (${note.timestamp})`);
+        if (note.content) lines.push(note.content);
+        lines.push('');
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format leader operational rules (dispatch + validation) from constants.
+ * @returns {string}
+ */
+function formatLeaderOperations() {
+  const lines = [
+    '', '## Dispatch OdM', '',
+    'OBLIGATOIRE : pour dispatcher un OdM, mets-le en READY_TO_DISPATCH. Le daemon nemesis orch le dispatche automatiquement.',
+    'Ne JAMAIS lancer claude --resume manuellement.', '',
+    `1. Verifie les agents disponibles :`,
+    `   nemesis team list`, '',
+    `2. Mets l'OdM en READY_TO_DISPATCH :`,
+    `   ${LEADER_DISPATCH.command}`, '',
+    ...LEADER_DISPATCH.flow.map(r => `- ${r}`), '',
+    '## QA', '',
+    ...LEADER_DISPATCH.qa.map(r => `- ${r}`), '',
+    '## Validation CR', '',
+    `- VALIDE : ${LEADER_VALIDATION.VALIDE}`,
+    '- REJET :',
+    ...LEADER_VALIDATION.REJET.map(r => `  - ${r}`),
+    `- Sur rejet : ${LEADER_VALIDATION.sur_rejet}`, '',
+    '## Interdictions', '',
+    ...LEADER_INTERDICTIONS.map(r => `- ${r}`), '',
+  ];
+  return lines.join('\n');
+}
+
+/**
+ * Format atoms as markdown lines.
+ * @param {Array} atoms
+ * @returns {string[]}
+ */
+function formatAtoms(atoms) {
+  const lines = [];
+  for (const atom of atoms) {
+    const content = typeof atom.content === 'object'
+      ? (atom.content.description || JSON.stringify(atom.content))
+      : atom.content;
+    lines.push(`- [${atom.priority || 'INFO'}] **${atom.occurrence || atom.label}** : ${content || ''}`);
+  }
+  return lines;
+}
+
+/**
+ * Build the unified context injection for an agent.
+ * Single canal: stdout. Driven by situation via client.navigate().
+ *
+ * @param {string} root - project root
+ * @param {string} agentName
+ * @param {'leader'|'expert'} role
+ * @param {string} situation - e.g. 'onboarding', 'debugging', 'general'
+ * @param {object} [opts]
+ * @param {string} [opts.projectId] - project ID for header
+ * @returns {Promise<string>} - markdown context to inject via stdout
+ */
+export async function buildUnifiedContext(root, agentName, role, situation, opts = {}) {
+  try {
+    const { createNemesisClient } = await import('../sync/nemesis-client.js');
+    const client = createNemesisClient({ projectRoot: root });
+
+    const header = [
+      '',
+      `# Contexte — ${agentName}`,
+      '',
+    ];
+
+    if (opts.projectId) header.push(`**Projet** : ${opts.projectId}`);
+    header.push(`**Role** : ${role}`, `**Situation** : ${situation}`, '');
+
+    const sections = [];
+
+    // 1. B00 gouvernance (always)
+    try {
+      const govData = await client.bloc('B00');
+      if (govData?.atoms?.length) {
+        sections.push('## Gouvernance', '', ...formatAtoms(govData.atoms), '');
+      }
+    } catch (e) { debug(`buildUnifiedContext B00: ${e.message}`); }
+
+    // 2. Situational bloc (if not general)
+    if (situation !== 'general') {
+      try {
+        const navData = await client.navigate(situation);
+        if (navData?.atoms?.length) {
+          sections.push(`## ${situation} (${navData.bloc})`, '', ...formatAtoms(navData.atoms), '');
+        }
+      } catch (e) { debug(`buildUnifiedContext nav ${situation}: ${e.message}`); }
+    }
+
+    // 3. Leader operations (dispatch + validation)
+    if (role === 'leader') {
+      sections.push(formatLeaderOperations());
+    }
+
+    // 4. Recent memory (notes + CRs)
+    const leaderName = role === 'expert' ? await detectLeaderAsync(root) : null;
+    const memory = getRecentMemory(root, agentName, role, leaderName);
+    if (memory) {
+      sections.push(memory);
+    }
+
+    // Return empty if no actual content sections
+    if (sections.length === 0) return '';
+
+    return [...header, ...sections].join('\n');
+  } catch (e) {
+    debug(`buildUnifiedContext: ${e.message}`);
+    return '';
+  }
+}
+
+/**
+ * Build a lightweight situation update injection.
+ * Used when situation changes during UserPromptSubmit (not full re-injection).
+ *
+ * @param {string} root - project root
+ * @param {string} newSituation
+ * @returns {Promise<string>}
+ */
+export async function buildSituationUpdate(root, newSituation) {
+  try {
+    const { createNemesisClient } = await import('../sync/nemesis-client.js');
+    const client = createNemesisClient({ projectRoot: root });
+
+    const navData = await client.navigate(newSituation);
+    if (!navData?.atoms?.length) return '';
+
+    const parts = [
+      '',
+      `# Mise a jour contexte — ${newSituation}`,
+      '',
+      `**Bloc** : ${navData.bloc}`,
+      '',
+    ];
+
+    parts.push(...formatAtoms(navData.atoms));
+    parts.push('');
+
+    return parts.join('\n');
+  } catch (e) {
+    debug(`buildSituationUpdate: ${e.message}`);
+    return '';
+  }
+}
+
+/**
+ * Detect leader agent name asynchronously.
+ */
+async function detectLeaderAsync(root) {
+  try {
+    const { readRegistry, getLanes } = await import('../core/registry.js');
+    const { detectProject } = await import('../core/project.js');
+    const project = detectProject(root);
+    if (!project) return null;
+    const reg = readRegistry(project.hcm_dir);
+    if (!reg) return null;
+    const lanes = getLanes(reg);
+    const leader = lanes.find(l => l.leader);
+    return leader?.name || leader?.id || null;
+  } catch (e) { debug(`detectLeaderAsync: ${e.message}`); return null; }
+}

package/lib/kairos/context-loader.js

@@ -0,0 +1,108 @@
+/**
+ * Context Loader — resolve full agent context from local files.
+ * Used by hooks to build Kairos context before injection.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readRegistry, getLanes } from '../core/registry.js';
+import { detectProject } from '../core/project.js';
+import { debug } from '../core/logger.js';
+
+/**
+ * Resolve the complete context for an agent from local HCM files.
+ *
+ * @param {string} projectRoot - project root directory
+ * @param {string} agentName - agent name (e.g. "Agent_Bot-CLI")
+ * @returns {{ agentId: string, projectId: string, kairosProfile: string|null, missionId: string|null, odmId: string|null, isLeader: boolean, role: string|null } | null}
+ */
+export function resolveAgentContext(projectRoot, agentName) {
+  try {
+    const project = detectProject(projectRoot);
+    if (!project) return null;
+
+    const reg = readRegistry(project.hcm_dir);
+    if (!reg) return null;
+
+    const lanes = getLanes(reg);
+    const lane = lanes.find(l => l.id === agentName || l.name === agentName);
+    if (!lane) return null;
+
+    const kairosProfile = resolveKairosProfile(project.hcm_dir, agentName);
+    const activeOdm = findActiveOdm(project.hcm_dir, agentName);
+
+    return {
+      agentId: lane.id || agentName,
+      projectId: project.id,
+      kairosProfile,
+      missionId: activeOdm?.missionId || null,
+      odmId: activeOdm?.odmId || null,
+      isLeader: !!lane.leader,
+      role: lane.role || null,
+    };
+  } catch (e) {
+    debug(`resolveAgentContext: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Resolve Kairos profile ID from contributor card.
+ * Scans .nemesis/HCM/contributors/CONTRIB-*.json for matching agent.
+ *
+ * @param {string} hcmDir
+ * @param {string} agentName
+ * @returns {string|null}
+ */
+export function resolveKairosProfile(hcmDir, agentName) {
+  const contribDir = join(hcmDir, 'contributors');
+  if (!existsSync(contribDir)) return null;
+
+  try {
+    const files = readdirSync(contribDir).filter(f => f.startsWith('CONTRIB-') && f.endsWith('.json'));
+    for (const file of files) {
+      const data = JSON.parse(readFileSync(join(contribDir, file), 'utf-8'));
+      const id = data.contributor_meta?.contributor_id || data.id || '';
+      const name = data.contributor_meta?.name || data.name || '';
+      if (id === agentName || name === agentName) {
+        const profiles = data.contributor_payload?.profiles || data.profiles || [];
+        return profiles[0] || null;
+      }
+    }
+  } catch (e) { debug(`resolveKairosProfile: ${e.message}`); }
+  return null;
+}
+
+/**
+ * Find the active OdM assigned to an agent.
+ * Scans .nemesis/HCM/odm/ for OdMs with matching assigned_to and active status.
+ *
+ * @param {string} hcmDir
+ * @param {string} agentName
+ * @returns {{ odmId: string, missionId: string|null, title: string } | null}
+ */
+export function findActiveOdm(hcmDir, agentName) {
+  const odmDir = join(hcmDir, 'odm');
+  if (!existsSync(odmDir)) return null;
+
+  const activeStatuses = new Set(['ASSIGNED', 'IN_PROGRESS', 'DRAFT']);
+
+  try {
+    const files = readdirSync(odmDir).filter(f => f.endsWith('.json') && !f.startsWith('legacy_'));
+    for (const file of files) {
+      const data = JSON.parse(readFileSync(join(odmDir, file), 'utf-8'));
+      const meta = data.odm_meta || {};
+      const assignee = meta.assigned_to?.actor_id || meta.assigned_to || '';
+      const status = meta.status || '';
+
+      if (assignee === agentName && activeStatuses.has(status)) {
+        return {
+          odmId: meta.odm_id || file.replace('.json', ''),
+          missionId: meta.mission_id || meta.contract_id || null,
+          title: data.odm_payload?.cadrage?.title || '',
+        };
+      }
+    }
+  } catch (e) { debug(`findActiveOdm: ${e.message}`); }
+  return null;
+}

package/lib/kairos/context-writer.js

@@ -0,0 +1,45 @@
+/**
+ * Context Writer — minimal situation tracking via .nemesis/.current-situation.
+ *
+ * All context injection now goes through stdout (context-injector.js).
+ * This module only persists/reads the current situation string.
+ */
+
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../core/logger.js';
+
+const SITUATION_FILENAME = '.current-situation';
+
+/**
+ * Read the current situation from .nemesis/.current-situation.
+ *
+ * @param {string} projectRoot
+ * @returns {string|null}
+ */
+export function readCurrentSituation(projectRoot) {
+  const filepath = join(projectRoot, '.nemesis', SITUATION_FILENAME);
+  if (!existsSync(filepath)) return null;
+
+  try {
+    const content = readFileSync(filepath, 'utf-8').trim();
+    return content || null;
+  } catch (e) {
+    debug(`readCurrentSituation: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Write the current situation to .nemesis/.current-situation.
+ *
+ * @param {string} projectRoot
+ * @param {string} situation - e.g. 'onboarding', 'debugging', 'general'
+ */
+export function writeCurrentSituation(projectRoot, situation) {
+  const nemesisDir = join(projectRoot, '.nemesis');
+  if (!existsSync(nemesisDir)) {
+    mkdirSync(nemesisDir, { recursive: true });
+  }
+  writeFileSync(join(nemesisDir, SITUATION_FILENAME), situation, 'utf-8');
+}