@arka-labs/nemesis 1.2.0

package/lib/core/notewriter/log.js

@@ -0,0 +1,112 @@
+import { readFileSync, writeFileSync, appendFileSync, existsSync, unlinkSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveLogPath, resolveLogDir, resolveAgentDir, ensureDir } from './paths.js';
+
+// In-memory pending turns — atomic write strategy
+const pendingTurns = new Map();
+
+export function openTurn(projectRoot, agentName, sessionId, turnNumber, promptText) {
+  const entry = {
+    turn: turnNumber,
+    session_id: sessionId,
+    timestamp_in: new Date().toISOString(),
+    in: promptText,
+  };
+  pendingTurns.set(sessionId, entry);
+
+  // Persist for inter-process hooks (UserPromptSubmit → Stop are separate processes)
+  const pendingDir = resolveAgentDir(projectRoot, agentName);
+  ensureDir(pendingDir);
+  const pendingFile = join(pendingDir, `.pending-turn-${sessionId}.json`);
+  writeFileSync(pendingFile, JSON.stringify(entry) + '\n', 'utf-8');
+}
+
+export function closeTurn(projectRoot, agentName, sessionId, responseText) {
+  let pending = pendingTurns.get(sessionId);
+
+  // Inter-process fallback: read .pending-turn file if Map is empty (hooks are separate processes)
+  if (!pending) {
+    const pendingDir = resolveAgentDir(projectRoot, agentName);
+    const pendingFile = join(pendingDir, `.pending-turn-${sessionId}.json`);
+    if (existsSync(pendingFile)) {
+      try {
+        pending = JSON.parse(readFileSync(pendingFile, 'utf-8'));
+        unlinkSync(pendingFile);
+      } catch (_e) { /* fallback: pending turn corrupted */ }
+    }
+  }
+
+  if (!pending) {
+    const entry = {
+      turn: 0,
+      session_id: sessionId,
+      timestamp_in: null,
+      timestamp_out: new Date().toISOString(),
+      in: null,
+      out: responseText,
+    };
+    writeEntry(projectRoot, agentName, sessionId, entry);
+    return entry;
+  }
+
+  const entry = {
+    ...pending,
+    timestamp_out: new Date().toISOString(),
+    out: responseText,
+  };
+
+  pendingTurns.delete(sessionId);
+  writeEntry(projectRoot, agentName, sessionId, entry);
+  return entry;
+}
+
+function writeEntry(projectRoot, agentName, sessionId, entry) {
+  const logDir = resolveLogDir(projectRoot, agentName);
+  ensureDir(logDir);
+  const logPath = resolveLogPath(projectRoot, agentName, sessionId);
+  appendFileSync(logPath, JSON.stringify(entry) + '\n', 'utf-8');
+}
+
+export function readLog(projectRoot, agentName, sessionId) {
+  const logPath = resolveLogPath(projectRoot, agentName, sessionId);
+  if (!existsSync(logPath)) return [];
+  const lines = readFileSync(logPath, 'utf-8').trim().split('\n');
+  const entries = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try { entries.push(JSON.parse(line)); }
+    catch (_e) { /* fallback: skip malformed entry */ }
+  }
+  return entries;
+}
+
+export function readLastEntry(projectRoot, agentName, sessionId) {
+  const entries = readLog(projectRoot, agentName, sessionId);
+  return entries.length > 0 ? entries[entries.length - 1] : null;
+}
+
+export function replaySession(projectRoot, agentName, sessionId) {
+  const entries = readLog(projectRoot, agentName, sessionId);
+  const messages = [];
+  for (const e of entries) {
+    if (e.in) messages.push({ role: 'user', content: e.in, timestamp: e.timestamp_in });
+    if (e.out) messages.push({ role: 'assistant', content: e.out, timestamp: e.timestamp_out });
+  }
+  return messages;
+}
+
+export function listLogFiles(projectRoot, agentName) {
+  const agentDir = resolveAgentDir(projectRoot, agentName);
+  const logsRoot = join(agentDir, 'logs');
+  if (!existsSync(logsRoot)) return [];
+  const months = readdirSync(logsRoot).filter(d => /^\d{4}-\d{2}$/.test(d)).sort().reverse();
+  const files = [];
+  for (const month of months) {
+    const monthDir = join(logsRoot, month);
+    const jsonls = readdirSync(monthDir).filter(f => f.endsWith('.jsonl')).sort().reverse();
+    for (const f of jsonls) {
+      files.push({ filename: f, path: join(monthDir, f), month });
+    }
+  }
+  return files;
+}

package/lib/core/notewriter/notes.js

@@ -0,0 +1,168 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveNotesDir, resolveCrDir, resolveAgentDir, ensureDir } from './paths.js';
+import { readNwRegistry, nextNoteId, registerNote, getLastCr } from './registry.js';
+
+const SYSTEM_PROMPT = `Tu es un systeme d'observation silencieux.
+Tu analyses un echange entre un PM et un agent IA.
+Tu ne fais PAS partie de la conversation. Tu observes.
+
+Ton role : extraire ce qui est notable de cet echange et produire une NOTE structuree.
+
+## Niveaux de profondeur
+
+Attribue UN niveau a cet echange :
+
+- L1 : Information passante, bruit, commande technique sans interet
+- L2 : Echange simple, confirmation, acquittement
+- L3 : Clarification, question importante, explication significative
+- L4 : Decision, choix structurant, arbitrage
+- L5 : Decision critique, pivot, changement de direction majeur
+
+## Format de sortie
+
+Reponds UNIQUEMENT avec un JSON valide (pas de markdown, pas de texte avant/apres) :
+
+{
+  "level": "L3",
+  "inputSummary": "Resume court du prompt user (1 phrase)",
+  "content": "Ce qui est notable dans cet echange (2-5 phrases)",
+  "tags": ["technique", "decision"],
+  "extractedActions": ["Action identifiee 1"]
+}
+
+Tags possibles : technique, decision, scope, bug, architecture, ux, performance,
+securite, documentation, test, refactoring, clarification, validation, blocage.
+
+Si rien n'est notable (L1), mets content a une phrase et extractedActions a [].`;
+
+export { SYSTEM_PROMPT };
+
+export function buildNotePrompt(turnEntry, lastCrSummary) {
+  let prompt = '## Echange a analyser\n\n';
+  prompt += `**Prompt user :**\n${turnEntry.in || '(vide)'}\n\n`;
+  prompt += `**Reponse agent :**\n${turnEntry.out || '(vide)'}\n\n`;
+  if (lastCrSummary) {
+    prompt += `## Contexte (dernier CR)\n${lastCrSummary}\n`;
+  }
+  return prompt;
+}
+
+export function parseNoteResponse(text) {
+  try {
+    let json = text.trim();
+    if (json.startsWith('```')) {
+      json = json.replace(/^```[a-z]*\n?/, '').replace(/\n?```$/, '');
+    }
+    const parsed = JSON.parse(json);
+    return {
+      level: parsed.level || 'L1',
+      inputSummary: parsed.inputSummary || '',
+      content: parsed.content || '',
+      tags: Array.isArray(parsed.tags) ? parsed.tags : [],
+      extractedActions: Array.isArray(parsed.extractedActions) ? parsed.extractedActions : [],
+    };
+  } catch (_e) {
+    return {
+      level: 'L2',
+      inputSummary: 'Reponse LLM non parsable',
+      content: text.slice(0, 500),
+      tags: [],
+      extractedActions: [],
+    };
+  }
+}
+
+export async function generateNote(projectRoot, agentName, turnEntry, callLlm) {
+  // 1. Contexte CR precedent
+  const lastCr = getLastCr(projectRoot, agentName);
+  let lastCrSummary = null;
+  if (lastCr) {
+    const crDir = resolveCrDir(projectRoot, agentName);
+    const crPath = join(crDir, `${lastCr.id}.json`);
+    if (existsSync(crPath)) {
+      try {
+        const crData = JSON.parse(readFileSync(crPath, 'utf-8'));
+        lastCrSummary = crData.summary || crData.previousCrSummary || null;
+      } catch (_e) { /* fallback: previous CR unreadable */ }
+    }
+  }
+
+  // 2. Construire le prompt
+  const userPrompt = buildNotePrompt(turnEntry, lastCrSummary);
+
+  // 3. Appeler le LLM
+  let llmResponse;
+  try {
+    llmResponse = await callLlm(SYSTEM_PROMPT, userPrompt);
+  } catch (err) {
+    llmResponse = JSON.stringify({
+      level: 'L1',
+      inputSummary: turnEntry.in?.slice(0, 100) || '',
+      content: `Erreur LLM: ${err.message}`,
+      tags: ['erreur-llm'],
+      extractedActions: [],
+    });
+  }
+
+  // 4. Parser la reponse
+  const parsed = parseNoteResponse(llmResponse);
+
+  // 5. Construire la note complete
+  const noteId = nextNoteId(projectRoot, agentName);
+  const note = {
+    id: noteId,
+    projectId: null,
+    agentId: agentName,
+    sessionId: turnEntry.session_id,
+    turn: turnEntry.turn,
+    level: parsed.level,
+    timestamp: turnEntry.timestamp_out || new Date().toISOString(),
+    previousCrId: lastCr?.id || null,
+    inputSummary: parsed.inputSummary,
+    content: parsed.content,
+    tags: parsed.tags,
+    extractedActions: parsed.extractedActions,
+    generatedAt: new Date().toISOString(),
+    llmProvider: callLlm.lastProvider || null,
+    llmFallback: callLlm.wasFallback || false,
+  };
+
+  // 6. Ecrire le fichier
+  const notesDir = resolveNotesDir(projectRoot, agentName);
+  ensureDir(notesDir);
+  const notePath = join(notesDir, `${noteId}.json`);
+  writeFileSync(notePath, JSON.stringify(note, null, 2) + '\n', 'utf-8');
+
+  // 7. Mettre a jour le registry
+  registerNote(projectRoot, agentName, {
+    id: noteId,
+    level: parsed.level,
+    timestamp: note.timestamp,
+    sessionId: turnEntry.session_id,
+    crId: lastCr?.id || null,
+    tags: parsed.tags,
+  });
+
+  return note;
+}
+
+export function readNote(projectRoot, agentName, noteId) {
+  const agentDir = resolveAgentDir(projectRoot, agentName);
+  const notesRoot = join(agentDir, 'notes');
+  if (!existsSync(notesRoot)) return null;
+  const months = readdirSync(notesRoot).filter(d => /^\d{4}-\d{2}$/.test(d));
+  for (const month of months) {
+    const filePath = join(notesRoot, month, `${noteId}.json`);
+    if (existsSync(filePath)) {
+      try { return JSON.parse(readFileSync(filePath, 'utf-8')); }
+      catch (_e) { /* fallback: corrupted note */ return null; }
+    }
+  }
+  return null;
+}
+
+export function listNotes(projectRoot, agentName) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  return reg.notes;
+}

package/lib/core/notewriter/paths.js

@@ -0,0 +1,45 @@
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+
+export function agentShort(agentName) {
+  return agentName.replace(/^Agent_/i, '');
+}
+
+export function resolveAgentDir(projectRoot, agentName) {
+  return join(projectRoot, '.nemesis', 'claude', agentName);
+}
+
+export function resolveLogDir(projectRoot, agentName) {
+  const now = new Date();
+  const month = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+  return join(resolveAgentDir(projectRoot, agentName), 'logs', month);
+}
+
+export function resolveLogPath(projectRoot, agentName, sessionId) {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+  const dir = resolveLogDir(projectRoot, agentName);
+  return join(dir, `${date}-${sessionId}.jsonl`);
+}
+
+export function resolveNotesDir(projectRoot, agentName) {
+  const now = new Date();
+  const month = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+  return join(resolveAgentDir(projectRoot, agentName), 'notes', month);
+}
+
+export function resolveCrDir(projectRoot, agentName) {
+  return join(resolveAgentDir(projectRoot, agentName), 'cr');
+}
+
+export function resolveRegistryPath(projectRoot, agentName) {
+  return join(resolveAgentDir(projectRoot, agentName), 'registry.json');
+}
+
+export function resolvePendingCrPath(projectRoot, agentName) {
+  return join(resolveAgentDir(projectRoot, agentName), '.pending-cr');
+}
+
+export function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+}

package/lib/core/notewriter/reader.js

@@ -0,0 +1,121 @@
+import { readNote, listNotes } from './notes.js';
+import { readCr, listCrs } from './cr.js';
+import { detectProject } from '../project.js';
+import { readRegistry, getLanes } from '../registry.js';
+
+export function loadAgentEntries(projectRoot, agentName) {
+  const entries = [];
+  const agentShort = agentName.replace(/^Agent_/i, '');
+
+  // Notes
+  const noteRefs = listNotes(projectRoot, agentName);
+  for (const ref of noteRefs) {
+    const note = readNote(projectRoot, agentName, ref.id);
+    if (!note) continue;
+    entries.push({
+      type: 'NOTE', id: note.id, agentId: agentName, agentShort,
+      level: note.level, timestamp: note.timestamp,
+      sessionId: note.sessionId, tags: note.tags || [],
+      trigger: null, data: note,
+    });
+  }
+
+  // CRs
+  const crRefs = listCrs(projectRoot, agentName);
+  for (const ref of crRefs) {
+    const cr = readCr(projectRoot, agentName, ref.id);
+    if (!cr) continue;
+    entries.push({
+      type: 'CR', id: cr.id, agentId: agentName, agentShort,
+      level: null, timestamp: cr.generatedAt || cr.period?.to,
+      sessionId: cr.sessionId, tags: [],
+      trigger: cr.trigger, data: cr,
+    });
+  }
+
+  // Tri par timestamp desc
+  entries.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+  return entries;
+}
+
+export function loadProjectTimeline(projectRoot) {
+  const project = detectProject(projectRoot);
+  if (!project) return [];
+  const reg = readRegistry(project.hcm_dir);
+  if (!reg) return [];
+  const lanes = getLanes(reg);
+  if (!lanes || lanes.length === 0) return [];
+
+  const allEntries = [];
+  for (const lane of lanes) {
+    const agentEntries = loadAgentEntries(projectRoot, lane.name);
+    allEntries.push(...agentEntries);
+  }
+  allEntries.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+  return allEntries;
+}
+
+export function applyFilters(entries, filters = {}) {
+  let result = entries;
+
+  if (filters.type) {
+    result = result.filter(e => e.type === filters.type);
+  }
+
+  if (filters.levels?.length > 0) {
+    result = result.filter(e => {
+      if (e.type === 'CR') return true; // CR passe tous les filtres de niveau
+      return filters.levels.includes(e.level);
+    });
+  }
+
+  if (filters.tags?.length > 0) {
+    result = result.filter(e =>
+      e.tags.some(t => filters.tags.includes(t))
+    );
+  }
+
+  if (filters.dateFrom) {
+    result = result.filter(e => (e.timestamp || '') >= filters.dateFrom);
+  }
+
+  if (filters.dateTo) {
+    result = result.filter(e => (e.timestamp || '') <= filters.dateTo);
+  }
+
+  if (filters.sessionId) {
+    result = result.filter(e => e.sessionId === filters.sessionId);
+  }
+
+  if (filters.content === 'decisions') {
+    result = result.filter(e => {
+      if (e.type === 'CR') return (e.data.decisions?.length > 0);
+      return e.level === 'L4' || e.level === 'L5';
+    });
+  }
+
+  if (filters.content === 'actions') {
+    result = result.filter(e => {
+      if (e.type === 'CR') return (e.data.actions?.length > 0);
+      return (e.data.extractedActions?.length > 0);
+    });
+  }
+
+  return result;
+}
+
+export function getAllTags(entries) {
+  const tags = new Set();
+  for (const e of entries) {
+    for (const t of e.tags) tags.add(t);
+  }
+  return [...tags].sort();
+}
+
+export function getAllSessions(entries) {
+  const sessions = new Set();
+  for (const e of entries) {
+    if (e.sessionId) sessions.add(e.sessionId);
+  }
+  return [...sessions];
+}

package/lib/core/notewriter/registry.js

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { resolveRegistryPath, agentShort, ensureDir } from './paths.js';
+
+export function readNwRegistry(projectRoot, agentName) {
+  const path = resolveRegistryPath(projectRoot, agentName);
+  if (!existsSync(path)) {
+    return {
+      agentId: agentName,
+      notes: [],
+      crs: [],
+      lastCrId: null,
+      lastNoteId: null,
+      updatedAt: null,
+    };
+  }
+  try { return JSON.parse(readFileSync(path, 'utf-8')); }
+  catch (_e) { /* fallback: corrupted registry */ return { agentId: agentName, notes: [], crs: [], lastCrId: null, lastNoteId: null, updatedAt: null }; }
+}
+
+export function writeNwRegistry(projectRoot, agentName, registry) {
+  const path = resolveRegistryPath(projectRoot, agentName);
+  ensureDir(dirname(path));
+  registry.updatedAt = new Date().toISOString();
+  writeFileSync(path, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
+}
+
+export function nextNoteId(projectRoot, agentName) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  const short = agentShort(agentName);
+  const prefix = `NOTE-${short}-`;
+  const existing = reg.notes.map(n => n.id);
+  let max = 0;
+  for (const id of existing) {
+    const match = id.match(new RegExp(`^${prefix.replace(/[-]/g, '\\-')}(\\d+)$`));
+    if (match) max = Math.max(max, parseInt(match[1]));
+  }
+  return `${prefix}${String(max + 1).padStart(3, '0')}`;
+}
+
+export function nextCrId(projectRoot, agentName) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  const short = agentShort(agentName);
+  const prefix = `CR-${short}-`;
+  const existing = reg.crs.map(c => c.id);
+  let max = 0;
+  for (const id of existing) {
+    const match = id.match(new RegExp(`^${prefix.replace(/[-]/g, '\\-')}(\\d+)$`));
+    if (match) max = Math.max(max, parseInt(match[1]));
+  }
+  return `${prefix}${String(max + 1).padStart(3, '0')}`;
+}
+
+export function registerNote(projectRoot, agentName, noteEntry) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  reg.notes.push(noteEntry);
+  reg.lastNoteId = noteEntry.id;
+  writeNwRegistry(projectRoot, agentName, reg);
+}
+
+export function registerCr(projectRoot, agentName, crEntry) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  reg.crs.push(crEntry);
+  reg.lastCrId = crEntry.id;
+  writeNwRegistry(projectRoot, agentName, reg);
+}
+
+export function getNotesSinceCr(projectRoot, agentName) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  if (!reg.lastCrId) return reg.notes;
+  const lastCr = reg.crs.find(c => c.id === reg.lastCrId);
+  if (!lastCr) return reg.notes;
+  return reg.notes.filter(n => n.timestamp > lastCr.timestamp);
+}
+
+export function getLastCr(projectRoot, agentName) {
+  const reg = readNwRegistry(projectRoot, agentName);
+  if (!reg.lastCrId) return null;
+  return reg.crs.find(c => c.id === reg.lastCrId) || null;
+}