@arka-labs/nemesis 1.2.0

package/src/commands/notes.js

@@ -0,0 +1,316 @@
+import { loadAgentEntries, loadProjectTimeline, applyFilters, getAllTags, getAllSessions } from '../../lib/core/notewriter/reader.js';
+import { readNote } from '../../lib/core/notewriter/notes.js';
+import { readCr } from '../../lib/core/notewriter/cr.js';
+import { detectProject } from '../../lib/core/project.js';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { renderAgentView, renderTimelineView } from '../../lib/ui/note-views.js';
+import { renderNoteDetail, renderCrDetail } from '../../lib/ui/note-detail.js';
+import { renderFilterPanel, formatFilterSummary } from '../../lib/ui/note-filters.js';
+import { renderNoteCard, renderCrCard } from '../../lib/ui/note-card.js';
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { style } from '../../lib/ui/colors.js';
+
+const HELP = `
+nemesis notes — Notes & CR — consultation memoire
+
+Usage: nemesis notes <subcommand>
+
+Subcommands:
+  agent <agent>    Vue par agent
+  timeline         Timeline projet (tous agents)
+  inspect <id>     Afficher une note ou un CR par ID
+  (sans argument)  Menu interactif
+  -h, --help       Aide
+
+Flags:
+  --cr             Filtre CR uniquement
+  --level <L>      Filtre par niveau (L1-L5)
+`;
+
+function getAgents(config) {
+  const project = detectProject(config.cwd);
+  if (!project) return [];
+  const reg = readRegistry(project.hcm_dir);
+  if (!reg) return [];
+  return getLanes(reg).map(l => l.name);
+}
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  // Parse --cr from args
+  const crFlagIndex = args.indexOf('--cr');
+  if (crFlagIndex !== -1) {
+    flags.cr = true;
+    args.splice(crFlagIndex, 1);
+  }
+
+  // Parse --level from args
+  const levelIdx = args.indexOf('--level');
+  let levelFlag = null;
+  if (levelIdx >= 0 && args[levelIdx + 1]) {
+    levelFlag = args[levelIdx + 1];
+  }
+
+  const sub = args[0];
+  switch (sub) {
+    case 'agent':    return handleAgent(args, flags, config, levelFlag);
+    case 'timeline': return handleTimeline(args, flags, config, levelFlag);
+    case 'inspect':  return handleInspect(args, flags, config);
+    default:         return handleMenu(args, flags, config, levelFlag);
+  }
+}
+
+async function handleMenu(args, flags, config, levelFlag) {
+  const agents = getAgents(config);
+
+  const items = [];
+  for (const agent of agents) {
+    const short = agent.replace(/^Agent_/i, '');
+    items.push({ label: `Notes \u2014 ${short}`, value: agent, description: `Notes et CR de ${short}` });
+  }
+  items.push({ label: 'Timeline projet', value: '__timeline__', description: 'Tous les agents' });
+
+  const choice = await interactiveMenu(items, { title: 'Notes & CR' });
+  if (!choice) return;
+
+  if (choice === '__timeline__') {
+    return handleTimeline(['timeline'], flags, config, levelFlag);
+  }
+
+  return handleAgent(['agent', choice], flags, config, levelFlag);
+}
+
+async function handleAgent(args, flags, config, levelFlag) {
+  const agentName = args[1];
+  if (!agentName) {
+    console.log('  Usage: nemesis notes agent <agent>');
+    return;
+  }
+
+  let allEntries = loadAgentEntries(config.cwd, agentName);
+  if (allEntries.length === 0) {
+    console.log(`  Aucune note ni CR pour ${agentName.replace(/^Agent_/i, '')}.`);
+    return;
+  }
+
+  // Initial filters from flags
+  let filters = {};
+  if (flags.cr) filters.type = 'CR';
+  if (levelFlag) filters.levels = [levelFlag];
+
+  // Navigation loop
+  while (true) {
+    const filtered = applyFilters(allEntries, filters);
+    const filterSummary = formatFilterSummary(filters);
+
+    // Empty results after filtering — let user change filters instead of quitting
+    if (filtered.length === 0 && Object.keys(filters).length > 0) {
+      process.stdout.write('\x1b[2J\x1b[H');
+      const agentShort = agentName.replace(/^Agent_/i, '');
+      console.log(`  ${style.bold(`Notes \u2014 ${agentShort}`)}`);
+      console.log(`  0 entrees \u00b7 filtre : ${filterSummary}`);
+      console.log('');
+      console.log(`  ${style.dim('Aucune entree pour ces filtres')}`);
+      console.log('');
+
+      const action = await interactiveMenu([
+        { label: 'Modifier les filtres',    value: 'filter', description: '' },
+        { label: 'Reinitialiser les filtres', value: 'reset',  description: '' },
+        { label: 'Quitter',                 value: 'quit',   description: '' },
+      ], { title: 'Que faire ?' });
+
+      if (!action || action === 'quit') break;
+      if (action === 'reset') { filters = {}; continue; }
+      if (action === 'filter') {
+        const tags = getAllTags(allEntries);
+        const sessions = getAllSessions(allEntries);
+        const filterResult = await renderFilterPanel(filters, tags, sessions);
+        if (filterResult.action === 'apply') filters = filterResult.filters;
+        else if (filterResult.action === 'reset') filters = {};
+        continue;
+      }
+      continue;
+    }
+
+    const result = await renderAgentView(filtered, {
+      agentName,
+      filterSummary,
+    });
+
+    if (result.action === 'quit') break;
+
+    if (result.action === 'filter') {
+      const tags = getAllTags(allEntries);
+      const sessions = getAllSessions(allEntries);
+      const filterResult = await renderFilterPanel(filters, tags, sessions);
+      if (filterResult.action === 'apply') filters = filterResult.filters;
+      else if (filterResult.action === 'reset') filters = {};
+      continue;
+    }
+
+    if (result.action === 'inspect' && result.entry) {
+      await navigateDetail(result.entry, filtered, config);
+      continue;
+    }
+  }
+}
+
+async function handleTimeline(args, flags, config, levelFlag) {
+  let allEntries = loadProjectTimeline(config.cwd);
+  if (allEntries.length === 0) {
+    console.log('  Aucune note ni CR sur le projet.');
+    return;
+  }
+
+  let filters = {};
+  if (flags.cr) filters.type = 'CR';
+  if (levelFlag) filters.levels = [levelFlag];
+
+  while (true) {
+    const filtered = applyFilters(allEntries, filters);
+    const filterSummary = formatFilterSummary(filters);
+
+    // Empty results after filtering
+    if (filtered.length === 0 && Object.keys(filters).length > 0) {
+      process.stdout.write('\x1b[2J\x1b[H');
+      console.log(`  ${style.bold('Timeline projet')}`);
+      console.log(`  0 entrees \u00b7 filtre : ${filterSummary}`);
+      console.log('');
+      console.log(`  ${style.dim('Aucune entree pour ces filtres')}`);
+      console.log('');
+
+      const action = await interactiveMenu([
+        { label: 'Modifier les filtres',    value: 'filter', description: '' },
+        { label: 'Reinitialiser les filtres', value: 'reset',  description: '' },
+        { label: 'Quitter',                 value: 'quit',   description: '' },
+      ], { title: 'Que faire ?' });
+
+      if (!action || action === 'quit') break;
+      if (action === 'reset') { filters = {}; continue; }
+      if (action === 'filter') {
+        const tags = getAllTags(allEntries);
+        const sessions = getAllSessions(allEntries);
+        const filterResult = await renderFilterPanel(filters, tags, sessions);
+        if (filterResult.action === 'apply') filters = filterResult.filters;
+        else if (filterResult.action === 'reset') filters = {};
+        continue;
+      }
+      continue;
+    }
+
+    const result = await renderTimelineView(filtered, {
+      filterSummary,
+    });
+
+    if (result.action === 'quit') break;
+
+    if (result.action === 'filter') {
+      const tags = getAllTags(allEntries);
+      const sessions = getAllSessions(allEntries);
+      const filterResult = await renderFilterPanel(filters, tags, sessions);
+      if (filterResult.action === 'apply') filters = filterResult.filters;
+      else if (filterResult.action === 'reset') filters = {};
+      continue;
+    }
+
+    if (result.action === 'inspect' && result.entry) {
+      await navigateDetail(result.entry, filtered, config);
+      continue;
+    }
+  }
+}
+
+async function navigateDetail(entry, entries, _config) {
+  let current = entry;
+  let currentIndex = entries.findIndex(e => e.id === current.id);
+
+  while (true) {
+    const context = { allEntries: entries, currentIndex };
+
+    let result;
+    if (current.type === 'CR') {
+      result = await renderCrDetail(current.data, context);
+    } else {
+      result = await renderNoteDetail(current.data, context);
+    }
+
+    if (result.action === 'back') break;
+
+    if (result.action === 'prev' && currentIndex > 0) {
+      currentIndex--;
+      current = entries[currentIndex];
+      continue;
+    }
+
+    if (result.action === 'next' && currentIndex < entries.length - 1) {
+      currentIndex++;
+      current = entries[currentIndex];
+      continue;
+    }
+
+    if (result.action === 'crParent' && result.data) {
+      const crEntry = entries.find(e => e.id === result.data);
+      if (crEntry) {
+        current = crEntry;
+        currentIndex = entries.indexOf(crEntry);
+      }
+      continue;
+    }
+
+    if (result.action === 'notes' && result.data) {
+      break; // Return to list
+    }
+
+    if (result.action === 'prevCr' && result.data) {
+      const prevCr = entries.find(e => e.id === result.data);
+      if (prevCr) {
+        current = prevCr;
+        currentIndex = entries.indexOf(prevCr);
+      }
+      continue;
+    }
+
+    if (result.action === 'nextCr') {
+      const nextCrIdx = entries.findIndex((e, i) => i > currentIndex && e.type === 'CR');
+      if (nextCrIdx >= 0) {
+        current = entries[nextCrIdx];
+        currentIndex = nextCrIdx;
+      }
+      continue;
+    }
+  }
+}
+
+async function handleInspect(args, flags, config) {
+  const itemId = args[1];
+  if (!itemId) {
+    console.log('  Usage: nemesis notes inspect <id>');
+    return;
+  }
+
+  const agents = getAgents(config);
+
+  for (const agent of agents) {
+    if (itemId.startsWith('NOTE-')) {
+      const note = readNote(config.cwd, agent, itemId);
+      if (note) {
+        const card = renderNoteCard(note);
+        for (const line of card) console.log(line);
+        return;
+      }
+    } else if (itemId.startsWith('CR-')) {
+      const cr = readCr(config.cwd, agent, itemId);
+      if (cr) {
+        const card = renderCrCard(cr);
+        for (const line of card) console.log(line);
+        return;
+      }
+    }
+  }
+
+  console.log(`  ID ${itemId} non trouve.`);
+}

package/src/commands/notewriter.js

@@ -0,0 +1,296 @@
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { renderTable } from '../../lib/ui/table.js';
+import { titledBox } from '../../lib/ui/box.js';
+import { style } from '../../lib/ui/colors.js';
+import { BACK_ITEM, HOME_ITEM } from './_helpers.js';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { readNwRegistry, getNotesSinceCr, getLastCr } from '../../lib/core/notewriter/registry.js';
+import { readNote, listNotes } from '../../lib/core/notewriter/notes.js';
+import { readCr, listCrs, generateCR } from '../../lib/core/notewriter/cr.js';
+import { replaySession, listLogFiles } from '../../lib/core/notewriter/log.js';
+import { readNotewriterConfig } from '../../lib/core/notewriter/config.js';
+import { agentShort } from '../../lib/core/notewriter/paths.js';
+
+const HELP = `
+nemesis notewriter — Memoire agent (notes, CR, replay)
+
+Usage: nemesis notewriter [subcommand]
+
+Subcommands:
+  status <agent>           Etat NoteWriter d'un agent
+  cr <agent>               Generer un CR manuel
+  list <agent>             Lister notes et CR
+  inspect <agent> <id>     Inspecter une note ou un CR
+  replay <agent> [session] Rejouer une session
+  -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];
+  switch (sub) {
+    case 'status':  return handleStatus(args, flags, config);
+    case 'cr':      return handleCr(args, flags, config);
+    case 'list':    return handleList(args, flags, config);
+    case 'inspect': return handleInspect(args, flags, config);
+    case 'replay':  return handleReplay(args, flags, config);
+    default:        return handleMenu(args, flags, config);
+  }
+}
+
+// --- Helpers ---
+
+import { detectProject } from '../../lib/core/project.js';
+
+async function pickAgent(config, prompt = 'Agent a inspecter') {
+  const project = detectProject(config.cwd);
+  if (!project) { console.log('  Aucun projet detecte.'); return null; }
+  const registry = readRegistry(project.hcm_dir);
+  if (!registry) { console.log('  Aucun registry.'); return null; }
+  const lanes = getLanes(registry);
+  if (lanes.length === 0) { console.log('  Aucun agent enregistre.'); return null; }
+
+  const items = lanes.map(l => ({
+    label: `${l.name}  ${style.dim(l.role || '')}`,
+    value: l.name,
+  }));
+  items.push(BACK_ITEM, HOME_ITEM);
+
+  const choice = await interactiveMenu(items, { title: prompt });
+  if (!choice || choice === '__back__') return null;
+  if (choice === '__home__') return '__home__';
+  return choice;
+}
+
+// --- status ---
+
+async function handleStatus(args, flags, config) {
+  let agentName = args[1];
+  if (!agentName) agentName = await pickAgent(config, 'Status — choisir un agent');
+  if (!agentName) return;
+  if (agentName === '__home__') return '__home__';
+
+  showStatus(config.cwd, agentName);
+}
+
+function showStatus(projectRoot, agentName) {
+  const nwReg = readNwRegistry(projectRoot, agentName);
+  const nwConfig = readNotewriterConfig(projectRoot);
+  const notesSinceCr = getNotesSinceCr(projectRoot, agentName);
+  const lastCr = getLastCr(projectRoot, agentName);
+  const logFiles = listLogFiles(projectRoot, agentName);
+
+  const lines = [
+    `Notes totales :  ${style.bold(String(nwReg.notes.length))}`,
+    `CR totaux :      ${style.bold(String(nwReg.crs.length))}`,
+    `Notes depuis CR: ${style.bold(String(notesSinceCr.length))}`,
+    `Dernier CR :     ${lastCr ? `${lastCr.id} (${lastCr.timestamp})` : style.dim('Aucun')}`,
+    `Derniere note :  ${nwReg.lastNoteId || style.dim('Aucune')}`,
+    `Sessions log :   ${logFiles.length}`,
+    '',
+    style.dim('Config :'),
+    `  Notes actives :  ${nwConfig.note_enabled ? style.green('Oui') : style.red('Non')}`,
+    `  CR actifs :      ${nwConfig.cr_enabled ? style.green('Oui') : style.red('Non')}`,
+    `  Timer CR :       ${nwConfig.cr_timer_minutes} min`,
+    `  Seuil CR :       ${nwConfig.cr_min_level_for_inclusion}`,
+  ];
+
+  console.log(titledBox(`NoteWriter — ${agentShort(agentName)}`, lines, { border: style.arkaRed }));
+}
+
+// --- cr ---
+
+async function handleCr(args, flags, config) {
+  let agentName = args[1];
+  if (!agentName) agentName = await pickAgent(config, 'CR manuel — choisir un agent');
+  if (!agentName) return;
+  if (agentName === '__home__') return '__home__';
+
+  const notesSinceCr = getNotesSinceCr(config.cwd, agentName);
+  if (notesSinceCr.length === 0) {
+    console.log('  Aucune note depuis le dernier CR. Rien a generer.');
+    return;
+  }
+
+  console.log(`  Generation CR manuel pour ${agentShort(agentName)} (${notesSinceCr.length} notes)...`);
+
+  let callLlm;
+  try {
+    const mod = await import('../../lib/sync/service-session.js');
+    callLlm = mod.createServiceCaller(config.cwd, 'notes');
+  } catch {
+    console.log('  Service LLM notes non configure. CR impossible.');
+    return;
+  }
+
+  const cr = await generateCR(config.cwd, agentName, 'manual', callLlm);
+  if (!cr) {
+    console.log('  Generation CR echouee (LLM ou pas de notes).');
+    return;
+  }
+
+  console.log(titledBox(`CR genere — ${cr.id}`, [
+    `Titre   : ${cr.title}`,
+    `Notes   : ${cr.noteCount}`,
+    `Periode : ${cr.period.from} → ${cr.period.to}`,
+    '',
+    cr.summary,
+  ], { border: style.arkaRed }));
+}
+
+// --- list ---
+
+async function handleList(args, flags, config) {
+  let agentName = args[1];
+  if (!agentName) agentName = await pickAgent(config, 'Lister — choisir un agent');
+  if (!agentName) return;
+  if (agentName === '__home__') return '__home__';
+
+  const notes = listNotes(config.cwd, agentName);
+  const crs = listCrs(config.cwd, agentName);
+
+  const items = [];
+  for (const n of notes) {
+    items.push({ type: 'NOTE', id: n.id, level: n.level || '-', timestamp: n.timestamp || '-', tags: (n.tags || []).join(', ') });
+  }
+  for (const c of crs) {
+    items.push({ type: 'CR', id: c.id, level: '-', timestamp: c.timestamp || '-', tags: c.trigger || '-' });
+  }
+  items.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+
+  if (items.length === 0) {
+    console.log(`  Aucune note ni CR pour ${agentShort(agentName)}.`);
+    return;
+  }
+
+  renderTable(items, {
+    columns: ['type', 'id', 'level', 'timestamp', 'tags'],
+    headers: ['Type', 'ID', 'Niveau', 'Date', 'Tags'],
+  });
+}
+
+// --- inspect ---
+
+async function handleInspect(args, flags, config) {
+  const agentName = args[1];
+  const itemId = args[2];
+  if (!agentName || !itemId) {
+    console.log('  Usage: nemesis notewriter inspect <agent> <id>');
+    return;
+  }
+
+  if (itemId.startsWith('NOTE-')) {
+    const note = readNote(config.cwd, agentName, itemId);
+    if (!note) { console.log(`  Note ${itemId} non trouvee.`); return; }
+
+    console.log(titledBox(`NOTE — ${note.id} [${note.level}]`, [
+      `Agent    : ${note.agentId}`,
+      `Session  : ${note.sessionId}`,
+      `Tour     : ${note.turn}`,
+      `Date     : ${note.timestamp}`,
+      `CR ref   : ${note.previousCrId || '-'}`,
+      '',
+      `Resume prompt : ${note.inputSummary}`,
+      '',
+      note.content,
+      '',
+      `Tags    : ${(note.tags || []).join(', ') || '-'}`,
+      `Actions : ${(note.extractedActions || []).join(', ') || '-'}`,
+    ], { border: style.arkaRed }));
+  } else if (itemId.startsWith('CR-')) {
+    const cr = readCr(config.cwd, agentName, itemId);
+    if (!cr) { console.log(`  CR ${itemId} non trouve.`); return; }
+
+    console.log(titledBox(`CR — ${cr.id}`, [
+      `Titre      : ${cr.title}`,
+      `Trigger    : ${cr.trigger}`,
+      `Periode    : ${cr.period?.from || '-'} → ${cr.period?.to || '-'}`,
+      `CR prec.   : ${cr.previousCrId || '-'}`,
+      `Notes      : ${cr.noteCount} (${(cr.noteIds || []).join(', ')})`,
+      '',
+      '--- Resume ---',
+      cr.summary || '-',
+      '',
+      '--- Decisions ---',
+      ...(cr.decisions || []).map(d => `  - ${d}`),
+      '',
+      '--- Actions ---',
+      ...(cr.actions || []).map(a => `  - ${a}`),
+      '',
+      '--- Recontextualisation ---',
+      cr.recontextualization || '-',
+    ], { border: style.arkaRed }));
+  } else {
+    console.log(`  ID ${itemId} non reconnu. Attendu : NOTE-xxx ou CR-xxx.`);
+  }
+}
+
+// --- replay ---
+
+async function handleReplay(args, flags, config) {
+  let agentName = args[1];
+  if (!agentName) {
+    console.log('  Usage: nemesis notewriter replay <agent> [session]');
+    return;
+  }
+
+  const sessionId = args[2];
+  if (!sessionId) {
+    const files = listLogFiles(config.cwd, agentName);
+    if (files.length === 0) {
+      console.log(`  Aucun log pour ${agentShort(agentName)}.`);
+      return;
+    }
+    console.log(`\n  Sessions disponibles pour ${agentShort(agentName)} :\n`);
+    for (const f of files) {
+      console.log(`    ${f.filename}  ${style.dim(`(${f.month})`)}`);
+    }
+    return;
+  }
+
+  const messages = replaySession(config.cwd, agentName, sessionId);
+  if (messages.length === 0) {
+    console.log(`  Session ${sessionId} vide ou introuvable.`);
+    return;
+  }
+
+  console.log(`\n  Replay session ${sessionId} — ${messages.length} messages\n`);
+  for (const msg of messages) {
+    const role = msg.role === 'user' ? style.bold('► USER') : style.nemesisAccent('◄ AGENT');
+    const time = msg.timestamp ? style.dim(`[${msg.timestamp}]`) : '';
+    console.log(`  ${role} ${time}`);
+    const content = msg.content?.length > 500 ? msg.content.slice(0, 500) + '...' : msg.content;
+    console.log(`    ${content}`);
+    console.log('');
+  }
+}
+
+// --- menu ---
+
+async function handleMenu(args, flags, config) {
+  const items = [
+    { label: 'Status agent',       value: 'status',  description: 'Etat NoteWriter d\'un agent' },
+    { label: 'Generer CR manuel',   value: 'cr',      description: 'Generer un compte-rendu' },
+    { label: 'Lister notes/CR',     value: 'list',    description: 'Toutes les notes et CR' },
+    { label: 'Inspecter note/CR',   value: 'inspect', description: 'Voir le detail' },
+    { label: 'Rejouer session',     value: 'replay',  description: 'Replay depuis le log JSONL' },
+    BACK_ITEM,
+    HOME_ITEM,
+  ];
+
+  const choice = await interactiveMenu(items, { title: 'NoteWriter' });
+  if (!choice || choice === '__back__') return '__back__';
+  if (choice === '__home__') return '__home__';
+
+  switch (choice) {
+    case 'status':  return handleStatus([choice], flags, config);
+    case 'cr':      return handleCr([choice], flags, config);
+    case 'list':    return handleList([choice], flags, config);
+    case 'inspect': return handleInspect([choice], flags, config);
+    case 'replay':  return handleReplay([choice], flags, config);
+  }
+}