@arka-labs/nemesis 1.2.0

package/lib/ui/note-views.js

@@ -0,0 +1,283 @@
+import { emitKeypressEvents } from 'node:readline';
+import { renderNoteCard, renderCrCard, formatTime } from './note-card.js';
+import { style } from './colors.js';
+
+const MAX_VISIBLE = 5;
+
+function renderCard(entry, isActive) {
+  const card = entry.type === 'CR'
+    ? renderCrCard(entry.data, { compact: !isActive })
+    : renderNoteCard(entry.data, { compact: !isActive });
+  return card.map(line => isActive ? style.bold(line) : style.dim(line));
+}
+
+function timeGroup(ts) {
+  if (!ts) return '--:--';
+  const t = formatTime(ts);
+  // Round to 5-minute groups
+  const h = t.slice(0, 2);
+  const m = String(Math.floor(parseInt(t.slice(3)) / 5) * 5).padStart(2, '0');
+  return `${h}:${m}`;
+}
+
+export async function renderAgentView(entries, options = {}) {
+  const { stdin, stdout } = process;
+  if (!stdin.isTTY) return { action: 'quit' };
+  if (entries.length === 0) return { action: 'quit' };
+
+  return new Promise(resolve => {
+    let cursor = 0;
+    let viewOffset = 0;
+    const maxVisible = Math.min(entries.length, MAX_VISIBLE);
+
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    // Clear screen before initial render to avoid stacking
+    stdout.write('\x1b[2J\x1b[H');
+    let lastLineCount = 0;
+
+    function adjustViewport() {
+      if (cursor < viewOffset) viewOffset = cursor;
+      if (cursor >= viewOffset + maxVisible) viewOffset = cursor - maxVisible + 1;
+    }
+
+    function draw() {
+      const lines = [];
+
+      // Header
+      const agentShort = (options.agentName || '').replace(/^Agent_/i, '');
+      const filterInfo = options.filterSummary || 'aucun';
+      lines.push(`  ${style.bold(`Notes \u2014 ${agentShort}`)}`);
+      lines.push(`  ${entries.length} entrees \u00b7 filtre : ${filterInfo}`);
+      lines.push('');
+
+      // Scroll up
+      if (viewOffset > 0) {
+        lines.push(`    ${style.dim(`\u25b2 ${viewOffset} de plus`)}`);
+      } else if (entries.length > maxVisible) {
+        lines.push('');
+      }
+
+      // Visible cards
+      const visible = entries.slice(viewOffset, viewOffset + maxVisible);
+      for (let i = 0; i < visible.length; i++) {
+        const isActive = (viewOffset + i) === cursor;
+        const cardLines = renderCard(visible[i], isActive);
+        lines.push(...cardLines);
+      }
+
+      // Scroll down
+      if (viewOffset + maxVisible < entries.length) {
+        const remaining = entries.length - viewOffset - maxVisible;
+        lines.push(`    ${style.dim(`\u25bc ${remaining} de plus`)}`);
+      } else if (entries.length > maxVisible) {
+        lines.push('');
+      }
+
+      // Footer navigation
+      lines.push('');
+      lines.push(`  ${style.dim('[\u2191\u2193 naviguer]  [Entree ouvrir]  [f filtrer]  [q quitter]')}`);
+
+      return lines;
+    }
+
+    function render() {
+      // Erase previous output
+      if (lastLineCount > 0) {
+        stdout.write(`\x1b[${lastLineCount}A\x1b[J`);
+      }
+      const lines = draw();
+      for (const l of lines) stdout.write(l + '\n');
+      lastLineCount = lines.length;
+    }
+
+    function cleanup() {
+      stdin.removeListener('keypress', onKeypress);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    function onKeypress(ch, key) {
+      if (!key) return;
+
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        resolve({ action: 'quit' });
+        return;
+      }
+
+      if (key.name === 'escape' || (ch === 'q' && !key.ctrl && !key.meta)) {
+        cleanup();
+        resolve({ action: 'quit' });
+        return;
+      }
+
+      if (key.name === 'return') {
+        cleanup();
+        resolve({ action: 'inspect', entry: entries[cursor] });
+        return;
+      }
+
+      if (ch === 'f' && !key.ctrl && !key.meta) {
+        cleanup();
+        resolve({ action: 'filter' });
+        return;
+      }
+
+      if (key.name === 'up' || ch === 'k') {
+        cursor = (cursor - 1 + entries.length) % entries.length;
+        adjustViewport();
+        render();
+        return;
+      }
+
+      if (key.name === 'down' || ch === 'j') {
+        cursor = (cursor + 1) % entries.length;
+        adjustViewport();
+        render();
+        return;
+      }
+    }
+
+    // Initial draw
+    render();
+    stdin.on('keypress', onKeypress);
+  });
+}
+
+export async function renderTimelineView(entries, options = {}) {
+  const { stdin, stdout } = process;
+  if (!stdin.isTTY) return { action: 'quit' };
+  if (entries.length === 0) return { action: 'quit' };
+
+  return new Promise(resolve => {
+    let cursor = 0;
+    let viewOffset = 0;
+    const maxVisible = Math.min(entries.length, MAX_VISIBLE);
+
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    // Clear screen before initial render to avoid stacking
+    stdout.write('\x1b[2J\x1b[H');
+    let lastLineCount = 0;
+
+    function adjustViewport() {
+      if (cursor < viewOffset) viewOffset = cursor;
+      if (cursor >= viewOffset + maxVisible) viewOffset = cursor - maxVisible + 1;
+    }
+
+    function draw() {
+      const lines = [];
+
+      // Header
+      const filterInfo = options.filterSummary || 'aucun';
+      const agentCount = new Set(entries.map(e => e.agentId)).size;
+      lines.push(`  ${style.bold('Timeline projet')}`);
+      lines.push(`  ${agentCount} agents \u00b7 ${entries.length} entrees \u00b7 filtre : ${filterInfo}`);
+      lines.push('');
+
+      // Scroll up
+      if (viewOffset > 0) {
+        lines.push(`    ${style.dim(`\u25b2 ${viewOffset} de plus`)}`);
+      } else if (entries.length > maxVisible) {
+        lines.push('');
+      }
+
+      // Visible cards with time separators
+      const visible = entries.slice(viewOffset, viewOffset + maxVisible);
+      let lastGroup = null;
+      for (let i = 0; i < visible.length; i++) {
+        const entry = visible[i];
+        const group = timeGroup(entry.timestamp);
+        if (group !== lastGroup) {
+          const sep = `\u2500\u2500 ${group} ` + '\u2500'.repeat(60);
+          lines.push(`  ${style.dim(sep)}`);
+          lastGroup = group;
+        }
+        const isActive = (viewOffset + i) === cursor;
+        const cardLines = renderCard(entry, isActive);
+        lines.push(...cardLines);
+      }
+
+      // Scroll down
+      if (viewOffset + maxVisible < entries.length) {
+        const remaining = entries.length - viewOffset - maxVisible;
+        lines.push(`    ${style.dim(`\u25bc ${remaining} de plus`)}`);
+      } else if (entries.length > maxVisible) {
+        lines.push('');
+      }
+
+      // Footer
+      lines.push('');
+      lines.push(`  ${style.dim('[\u2191\u2193 naviguer]  [Entree ouvrir]  [f filtrer]  [q quitter]')}`);
+
+      return lines;
+    }
+
+    function render() {
+      if (lastLineCount > 0) {
+        stdout.write(`\x1b[${lastLineCount}A\x1b[J`);
+      }
+      const lines = draw();
+      for (const l of lines) stdout.write(l + '\n');
+      lastLineCount = lines.length;
+    }
+
+    function cleanup() {
+      stdin.removeListener('keypress', onKeypress);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    function onKeypress(ch, key) {
+      if (!key) return;
+
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        resolve({ action: 'quit' });
+        return;
+      }
+
+      if (key.name === 'escape' || (ch === 'q' && !key.ctrl && !key.meta)) {
+        cleanup();
+        resolve({ action: 'quit' });
+        return;
+      }
+
+      if (key.name === 'return') {
+        cleanup();
+        resolve({ action: 'inspect', entry: entries[cursor] });
+        return;
+      }
+
+      if (ch === 'f' && !key.ctrl && !key.meta) {
+        cleanup();
+        resolve({ action: 'filter' });
+        return;
+      }
+
+      if (key.name === 'up' || ch === 'k') {
+        cursor = (cursor - 1 + entries.length) % entries.length;
+        adjustViewport();
+        render();
+        return;
+      }
+
+      if (key.name === 'down' || ch === 'j') {
+        cursor = (cursor + 1) % entries.length;
+        adjustViewport();
+        render();
+        return;
+      }
+    }
+
+    render();
+    stdin.on('keypress', onKeypress);
+  });
+}

package/lib/ui/prompt.js

@@ -0,0 +1,81 @@
+import { createInterface } from 'node:readline';
+
+/**
+ * Interactive prompts — stdin-based, zero deps.
+ */
+
+export async function askText(question, defaultValue = '') {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+
+  return new Promise(resolve => {
+    rl.question(`  ? ${question}${suffix} : `, answer => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+export async function askChoice(question, choices) {
+  console.log(`  ? ${question}`);
+  choices.forEach((c, i) => {
+    const label = typeof c === 'string' ? c : c.label;
+    const desc = typeof c === 'string' ? '' : (c.description ? ` — ${c.description}` : '');
+    const marker = i === 0 ? '›' : ' ';
+    console.log(`    ${marker} ${label}${desc}`);
+  });
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('  Choix (numero ou texte) : ', answer => {
+      rl.close();
+      const idx = parseInt(answer, 10);
+      if (!isNaN(idx) && idx >= 1 && idx <= choices.length) {
+        const c = choices[idx - 1];
+        resolve(typeof c === 'string' ? c : c.value || c.label);
+      } else {
+        const match = choices.find(c => {
+          const label = typeof c === 'string' ? c : c.label;
+          return label.toLowerCase().startsWith(answer.toLowerCase());
+        });
+        resolve(match ? (typeof match === 'string' ? match : match.value || match.label) : answer);
+      }
+    });
+  });
+}
+
+export async function askMultiChoice(question, choices) {
+  console.log(`  ? ${question} (numeros separes par virgules)`);
+  choices.forEach((c, i) => {
+    const label = typeof c === 'string' ? c : c.label;
+    console.log(`    ${i + 1}. ${label}`);
+  });
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('  Choix : ', answer => {
+      rl.close();
+      const indices = answer.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+      const selected = indices
+        .filter(i => i >= 1 && i <= choices.length)
+        .map(i => {
+          const c = choices[i - 1];
+          return typeof c === 'string' ? c : c.value || c.label;
+        });
+      resolve(selected);
+    });
+  });
+}
+
+export async function askConfirm(question, defaultYes = false) {
+  const hint = defaultYes ? '(Y/n)' : '(y/N)';
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(`  ? ${question} ${hint} › `, answer => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (!a) return resolve(defaultYes);
+      resolve(a === 'y' || a === 'yes' || a === 'oui');
+    });
+  });
+}

package/lib/ui/spinner.js

@@ -0,0 +1,139 @@
+/**
+ * Simple spinner — unicode frames, no deps.
+ */
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export function createSpinner(message) {
+  let frameIdx = 0;
+  let timer = null;
+
+  return {
+    start() {
+      process.stdout.write(`  ${FRAMES[0]} ${message}`);
+      timer = setInterval(() => {
+        frameIdx = (frameIdx + 1) % FRAMES.length;
+        process.stdout.write(`\r  ${FRAMES[frameIdx]} ${message}`);
+      }, 80);
+    },
+
+    update(newMessage) {
+      message = newMessage;
+    },
+
+    stop(finalMessage, symbol = '✓') {
+      if (timer) clearInterval(timer);
+      process.stdout.write(`\r  ${symbol} ${finalMessage || message}\n`);
+    },
+
+    fail(finalMessage) {
+      this.stop(finalMessage || message, '✗');
+    },
+  };
+}
+
+/**
+ * Multi-step spinner — shows progress through a list of steps.
+ * Format: ⠋ [2/3] Validation registre...
+ * Completed steps show ✓ above the current step.
+ *
+ * @param {string[]} steps — array of step labels
+ */
+export function createMultiStepSpinner(steps) {
+  const isTTY = process.stdout.isTTY;
+  let currentStep = 0;
+  let frameIdx = 0;
+  let timer = null;
+  let linesWritten = 0;
+
+  function clearLines() {
+    if (!isTTY || linesWritten === 0) return;
+    for (let i = 0; i < linesWritten; i++) {
+      process.stdout.write('\x1b[1A\x1b[2K');
+    }
+    linesWritten = 0;
+  }
+
+  function render(frame) {
+    const lines = [];
+    // Completed steps
+    for (let i = 0; i < currentStep; i++) {
+      lines.push(`  \u2713 [${i + 1}/${steps.length}] ${steps[i]}`);
+    }
+    // Current step with spinner
+    if (currentStep < steps.length) {
+      lines.push(`  ${frame} [${currentStep + 1}/${steps.length}] ${steps[currentStep]}...`);
+    }
+    return lines;
+  }
+
+  function draw() {
+    clearLines();
+    const lines = render(FRAMES[frameIdx]);
+    const output = lines.join('\n') + '\n';
+    process.stdout.write(output);
+    linesWritten = lines.length;
+  }
+
+  return {
+    start() {
+      if (!isTTY) {
+        // Non-TTY: print first step immediately
+        process.stdout.write(`  [1/${steps.length}] ${steps[0]}...\n`);
+        return;
+      }
+      draw();
+      timer = setInterval(() => {
+        frameIdx = (frameIdx + 1) % FRAMES.length;
+        draw();
+      }, 80);
+    },
+
+    nextStep() {
+      currentStep++;
+      if (!isTTY) {
+        if (currentStep < steps.length) {
+          process.stdout.write(`  [${currentStep + 1}/${steps.length}] ${steps[currentStep]}...\n`);
+        }
+        return;
+      }
+      draw();
+    },
+
+    complete(msg) {
+      if (timer) clearInterval(timer);
+      if (!isTTY) {
+        process.stdout.write(`  \u2713 ${msg || 'Termine'}\n`);
+        return;
+      }
+      clearLines();
+      // Show all steps as completed
+      for (let i = 0; i < steps.length; i++) {
+        process.stdout.write(`  \u2713 [${i + 1}/${steps.length}] ${steps[i]}\n`);
+      }
+      if (msg) {
+        process.stdout.write(`  \u2713 ${msg}\n`);
+      }
+    },
+
+    fail(msg) {
+      if (timer) clearInterval(timer);
+      if (!isTTY) {
+        process.stdout.write(`  \u2717 ${msg || 'Echec'}\n`);
+        return;
+      }
+      clearLines();
+      // Show completed steps
+      for (let i = 0; i < currentStep; i++) {
+        process.stdout.write(`  \u2713 [${i + 1}/${steps.length}] ${steps[i]}\n`);
+      }
+      // Show failed step
+      if (currentStep < steps.length) {
+        process.stdout.write(`  \u2717 [${currentStep + 1}/${steps.length}] ${steps[currentStep]}\n`);
+      }
+      if (msg) {
+        process.stdout.write(`  \u2717 ${msg}\n`);
+      }
+    },
+  };
+}

package/lib/ui/streambox.js

@@ -0,0 +1,46 @@
+/**
+ * StreamBox — fixed-height rolling output (N visible lines).
+ * TTY: uses ANSI cursor-up + clear-line to rewrite in place.
+ * Non-TTY / NO_COLOR: simple line-by-line stdout.write.
+ */
+
+import { isColorEnabled } from './colors.js';
+
+export function createStreamBox(maxLines = 4) {
+  const buffer = [];
+  let linesWritten = 0;
+  const isTTY = Boolean(process.stdout.isTTY) && isColorEnabled();
+
+  return {
+    push(line) {
+      const trimmed = line.replace(/\n+$/, '');
+      buffer.push(trimmed);
+      if (buffer.length > maxLines) buffer.shift();
+
+      if (isTTY) {
+        // Move cursor up to overwrite previous lines
+        if (linesWritten > 0) {
+          process.stdout.write(`\x1b[${linesWritten}A`);
+        }
+        for (let i = 0; i < buffer.length; i++) {
+          process.stdout.write(`\x1b[2K  ${buffer[i]}\n`);
+        }
+        linesWritten = buffer.length;
+      } else {
+        process.stdout.write(`  ${trimmed}\n`);
+      }
+    },
+
+    clear() {
+      if (isTTY && linesWritten > 0) {
+        process.stdout.write(`\x1b[${linesWritten}A`);
+        for (let i = 0; i < linesWritten; i++) {
+          process.stdout.write('\x1b[2K\n');
+        }
+        process.stdout.write(`\x1b[${linesWritten}A`);
+      }
+      buffer.length = 0;
+      linesWritten = 0;
+    },
+  };
+}

package/lib/ui/table.js

@@ -0,0 +1,42 @@
+/**
+ * ASCII table renderer — zero deps, emoji-aware.
+ */
+
+import { stringWidth, padEndVisible } from './box.js';
+
+export function renderTable(columns, rows, _opts = {}) {
+  if (!rows.length) {
+    return '  (aucune donnee)';
+  }
+
+  const widths = columns.map((col) => {
+    const header = col.label || col.key;
+    const maxData = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? '');
+      return Math.max(max, stringWidth(val));
+    }, 0);
+    return Math.max(stringWidth(header), maxData);
+  });
+
+  const hr = '  ' + border('\u250c', '\u252c', '\u2510', widths);
+  const sep = '  ' + border('\u251c', '\u253c', '\u2524', widths);
+  const bottom = '  ' + border('\u2514', '\u2534', '\u2518', widths);
+
+  const headerRow = '  ' + row(columns.map(c => c.label || c.key), widths);
+  const dataRows = rows.map(r => {
+    const cells = columns.map(c => String(r[c.key] ?? ''));
+    return '  ' + row(cells, widths);
+  });
+
+  return [hr, headerRow, sep, ...dataRows, bottom].join('\n');
+}
+
+function border(left, mid, right, widths) {
+  const segments = widths.map(w => '\u2500'.repeat(w + 2));
+  return left + segments.join(mid) + right;
+}
+
+function row(cells, widths) {
+  const padded = cells.map((cell, i) => ' ' + padEndVisible(cell, widths[i]) + ' ');
+  return '\u2502' + padded.join('\u2502') + '\u2502';
+}

package/lib/ui/tree.js

@@ -0,0 +1,33 @@
+/**
+ * Tree renderer — hierarchical display with unicode prefixes.
+ *
+ * Input: { label, children?: TreeNode[] }
+ */
+
+import { style } from './colors.js';
+
+export function renderTree(node, _opts = {}) {
+  const lines = [];
+  buildLines(node, '', true, lines, true);
+  return lines.map(l => '  ' + l).join('\n');
+}
+
+function buildLines(node, prefix, isLast, lines, isRoot = false) {
+  const connector = isRoot ? '' : (isLast ? '\u2514\u2500\u2500 ' : '\u251c\u2500\u2500 ');
+  const label = node.label || node.name || '(unknown)';
+
+  const styledConnector = connector ? style.dim(connector) : '';
+  let line = prefix + styledConnector + style.bold(label);
+  if (node.meta) {
+    line += style.dim(` (${node.meta})`);
+  }
+  lines.push(line);
+
+  const children = node.children || [];
+  children.forEach((child, i) => {
+    const childPrefix = isRoot
+      ? ''
+      : prefix + (isLast ? '    ' : style.dim('\u2502') + '   ');
+    buildLines(child, childPrefix, i === children.length - 1, lines);
+  });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@arka-labs/nemesis",
+  "version": "1.2.0",
+  "description": "PM cockpit for orchestrating AI agent teams — file-first, HCM-native, Kairos hooks",
+  "type": "module",
+  "bin": {
+    "nemesis": "./src/index.js"
+  },
+  "files": [
+    "src/",
+    "lib/",
+    "templates/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/ lib/",
+    "lint:fix": "eslint src/ lib/ --fix",
+    "prepublishOnly": "npm run lint && npm test",
+    "release": "npm test && git tag v$(node -p \"require('./package.json').version\") && git push --tags"
+  },
+  "keywords": [
+    "cli",
+    "agents",
+    "ai",
+    "llm",
+    "orchestration",
+    "project-management",
+    "hcm",
+    "arka-labs"
+  ],
+  "author": "ARKA LABS <contact@arkalabs.app>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arka-squad/arkalabs-nemesis-cli"
+  },
+  "homepage": "https://github.com/arka-squad/arkalabs-nemesis-cli#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "xstate": "^5.28.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^10.0.3",
+    "vitest": "^3.0.0"
+  }
+}