@arka-labs/nemesis 1.2.0

package/src/commands/doctor.js

@@ -0,0 +1,243 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { detectProject } from '../../lib/core/project.js';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { diagnoseHcm } from '../../lib/sync/health.js';
+import { readServices, SERVICE_IDS } from '../../lib/core/services.js';
+import { listConnexions } from '../../lib/core/connexions.js';
+import { verifyHooks, ALL_HOOKS } from '../../lib/kairos/hook-installer.js';
+import { style } from '../../lib/ui/colors.js';
+
+const HELP = `
+nemesis doctor — Diagnostic complet
+
+Usage: nemesis doctor
+
+Options:
+  -h, --help        Aide
+`;
+
+const HCM_EXPECTED_DIRS = [
+  'contracts', 'odm', 'cr', 'transactions', 'note',
+  'decisions', 'interventions', 'contributors', 'project', 'odm-cr-QA',
+];
+
+const EXPECTED_TEMPLATES = [
+  'template_ODM-NAME-000.json',
+  'template_CR-ODM-NAME-000.exemple.json',
+  'template_MISSION_CONTRACT.json',
+  'template_REGISTRY-PROJECT.json',
+  'template_DEC-NAME-000.json',
+  'template_INTV-NAME-000.json',
+  'template_CONTRIB-NAME.json',
+  'template_TXN-NAME-000.json',
+];
+
+const ok = (msg) => `    ${style.green('\u2713')} ${msg}`;
+const ko = (msg) => `    ${style.red('\u2717')} ${msg}`;
+const warn = (msg) => `    ${style.yellow('\u26A0')} ${msg}`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const project = detectProject(config.cwd);
+  let hasErrors = false;
+
+  // Check 1: Structure .nemesis/HCM/
+  console.log(`\n  ${style.bold('Structure .nemesis/HCM/')} :`);
+  if (!project) {
+    console.log(ko('Aucun projet detecte'));
+    hasErrors = true;
+  } else {
+    for (const dir of HCM_EXPECTED_DIRS) {
+      const path = join(project.hcm_dir, dir);
+      if (existsSync(path)) {
+        console.log(ok(`${dir}/`));
+      } else {
+        console.log(ko(`${dir}/ MANQUANT`));
+        hasErrors = true;
+      }
+    }
+    const processFile = join(project.hcm_dir, 'PROCESS.md');
+    if (existsSync(processFile)) {
+      console.log(ok('PROCESS.md'));
+    } else {
+      console.log(ko('PROCESS.md MANQUANT'));
+      hasErrors = true;
+    }
+  }
+
+  // Check 2: Templates
+  console.log(`\n  ${style.bold('Templates .nemesis/template/')} :`);
+  const templateDir = join(config.cwd, '.nemesis', 'template');
+  if (existsSync(templateDir)) {
+    const files = readdirSync(templateDir);
+    let found = 0;
+    for (const tmpl of EXPECTED_TEMPLATES) {
+      if (files.includes(tmpl)) found++;
+    }
+    if (found === EXPECTED_TEMPLATES.length) {
+      console.log(ok(`${found} templates presents`));
+    } else {
+      console.log(warn(`${found}/${EXPECTED_TEMPLATES.length} templates`));
+    }
+  } else {
+    console.log(ko('.nemesis/template/ MANQUANT'));
+    hasErrors = true;
+  }
+
+  // Check 3: Config
+  console.log(`\n  ${style.bold('Config')} :`);
+  const configFile = join(homedir(), '.nemesis', 'config.json');
+  if (existsSync(configFile)) {
+    console.log(ok('~/.nemesis/config.json'));
+  } else {
+    console.log(warn('~/.nemesis/config.json absent (defaults utilises)'));
+  }
+  if (project) {
+    console.log(ok(`Projet detecte : ${project.id}`));
+  }
+
+  // Check 4: HCM
+  console.log(`\n  ${style.bold('HCM')} :`);
+  try {
+    const hcmResult = await diagnoseHcm();
+    console.log(`    URL : ${hcmResult.url}`);
+    for (const check of hcmResult.checks) {
+      console.log(check.ok ? ok(`${check.label} : ${check.detail}`) : ko(`${check.label} : ${check.detail}`));
+    }
+    if (!hcmResult.ok) hasErrors = true;
+  } catch (err) {
+    console.log(ko(`Erreur : ${err.message}`));
+    hasErrors = true;
+  }
+
+  // Check 5: Registry vs CLAUDE.md
+  console.log(`\n  ${style.bold('Registre')} :`);
+  if (project) {
+    const registry = readRegistry(project.hcm_dir);
+    if (registry) {
+      const lanes = getLanes(registry);
+      console.log(ok(`REGISTRY (${lanes.length + 1} membres)`));
+
+      const claudeMdPath = join(homedir(), '.claude', 'CLAUDE.md');
+      if (existsSync(claudeMdPath)) {
+        const claudeContent = readFileSync(claudeMdPath, 'utf-8');
+        let syncCount = 0;
+        for (const lane of lanes) {
+          if (claudeContent.includes(lane.name || lane.id)) syncCount++;
+        }
+        if (syncCount === lanes.length) {
+          console.log(ok(`CLAUDE.md sync (${lanes.length} agents)`));
+        } else {
+          console.log(warn(`CLAUDE.md desync (${syncCount}/${lanes.length} agents)`));
+        }
+      }
+    } else {
+      console.log(ko('Registry introuvable'));
+      hasErrors = true;
+    }
+  }
+
+  // Check 6: Agent memory files
+  console.log(`\n  ${style.bold('Agents')} :`);
+  if (project) {
+    const registry = readRegistry(project.hcm_dir);
+    if (registry) {
+      const lanes = getLanes(registry);
+      for (const lane of lanes) {
+        if (lane.memory_path) {
+          const fullPath = join(project.root, lane.memory_path);
+          if (existsSync(fullPath)) {
+            const stat = statSync(fullPath);
+            const size = (stat.size / 1024).toFixed(1);
+            console.log(ok(`${lane.name || lane.id} : memory.md present (${size} KB)`));
+          } else {
+            console.log(ko(`${lane.name || lane.id} : memory.md MANQUANT`));
+            hasErrors = true;
+          }
+        }
+      }
+      if (lanes.length === 0) {
+        console.log('    (aucun agent enregistre)');
+      }
+    }
+  }
+
+  // Check 7: Services LLM
+  console.log(`\n  ${style.bold('Services')} :`);
+  if (project) {
+    const svcData = readServices(project.root);
+    const allConnexions = listConnexions();
+    const now = Date.now();
+    const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1000;
+
+    for (const sid of SERVICE_IDS) {
+      const svc = svcData.services[sid];
+      if (!svc) {
+        console.log(warn(`${sid} \u2014 non configure`));
+        continue;
+      }
+      const cx = allConnexions.find(c => c.id === svc.connexion_id);
+      if (!cx) {
+        console.log(ko(`${sid} \u2014 connexion manquante`));
+        hasErrors = true;
+        continue;
+      }
+      if (cx.status === 'connected') {
+        const latStr = cx.latency ? `, ${cx.latency}ms` : '';
+        console.log(ok(`${sid} \u2014 ${cx.name} (connected${latStr})`));
+      } else if (cx.status === 'error') {
+        console.log(ko(`${sid} \u2014 ${cx.name} (error)`));
+        hasErrors = true;
+      } else {
+        console.log(warn(`${sid} \u2014 ${cx.name} (non teste)`));
+      }
+      if (cx.last_tested && (now - new Date(cx.last_tested).getTime()) > SEVEN_DAYS) {
+        console.log(warn(`${sid} \u2014 ${cx.name} non teste depuis 7 jours`));
+      }
+      // Check fallbacks
+      for (const fb of (svc.fallback || [])) {
+        const fbCx = allConnexions.find(c => c.id === fb.connexion_id);
+        if (fbCx && fbCx.last_tested && (now - new Date(fbCx.last_tested).getTime()) > SEVEN_DAYS) {
+          console.log(warn(`${sid} \u2014 Fallback ${fbCx.name} non teste depuis 7 jours`));
+        }
+      }
+    }
+  } else {
+    console.log(warn('Pas de projet — services non verifies'));
+  }
+
+  // Check 8: Hooks Kairos
+  console.log(`\n  ${style.bold('Hooks Kairos')} :`);
+  if (project) {
+    const hookResult = verifyHooks(project.root);
+    const hookCount = Object.keys(ALL_HOOKS).length;
+    const activeCount = Object.values(hookResult.hooks).filter(Boolean).length;
+    if (activeCount === hookCount) {
+      console.log(ok(`Tous les hooks installes (${hookCount}/${hookCount})`));
+    } else if (activeCount > 0) {
+      console.log(warn(`${activeCount}/${hookCount} hooks installes`));
+    } else {
+      console.log(warn('Hooks non installes (nemesis services hooks setup)'));
+    }
+  } else {
+    console.log(warn('Pas de projet — hooks non verifies'));
+  }
+
+  // Summary
+  console.log('');
+  if (hasErrors) {
+    console.log(`  ${style.red('Des problemes ont ete detectes.')} Voir ci-dessus.`);
+    if (!project) {
+      console.log(`  ${style.dim('\u2192 Lancez')} nemesis init ${style.dim('pour creer un projet.')}`);
+    }
+    console.log('');
+  } else {
+    console.log(`  ${style.green('Tout est OK.')}\n`);
+  }
+}

package/src/commands/hcm.js

@@ -0,0 +1,147 @@
+import { createHcmClient } from '../../lib/sync/hcm-client.js';
+import { diagnoseHcm } from '../../lib/sync/health.js';
+import { fullSync } from '../../lib/sync/sync-engine.js';
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { createSpinner } from '../../lib/ui/spinner.js';
+import { formatOutput } from '../../lib/ui/format.js';
+import { askText } from '../../lib/ui/prompt.js';
+import { style } from '../../lib/ui/colors.js';
+import { ensureProject, BACK_ITEM, HOME_ITEM } from './_helpers.js';
+
+const HELP = `
+nemesis hcm — Synchronisation HCM
+
+Usage: nemesis hcm <subcommand> [options]
+
+Subcommands:
+  sync              Force la synchronisation vers HCM
+  status            Affiche le status HCM (connexion + stats)
+  search [query]    Recherche dans les documents HCM
+
+Options:
+  -h, --help        Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  let sub = args[0];
+  let subArgs = args.slice(1);
+
+  if (!sub) {
+    sub = await interactiveMenu([
+      { label: 'status', value: 'status', description: 'Status HCM (connexion + stats)' },
+      { label: 'sync',   value: 'sync',   description: 'Force la synchronisation' },
+      { label: 'search', value: 'search', description: 'Recherche dans les documents' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'nemesis hcm' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+    subArgs = [];
+  }
+
+  switch (sub) {
+    case 'sync':
+      return handleSync(flags, config);
+    case 'status':
+      return handleStatus(flags, config);
+    case 'search':
+      return handleSearch(subArgs, flags, config);
+    default:
+      console.error(`Sous-commande inconnue : ${sub}`);
+      console.log(HELP);
+  }
+}
+
+async function handleSync(flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  const spinner = createSpinner('Scanning .nemesis/HCM/...');
+  spinner.start();
+
+  const client = createHcmClient();
+
+  try {
+    const results = await fullSync(project.hcm_dir, client);
+    spinner.stop('Sync termine');
+
+    console.log('');
+    for (const detail of results.details) {
+      const symbol = detail.status === 'synced' ? '\u2713' : detail.status === 'error' ? '\u2717' : '\u2713';
+      const suffix = detail.status === 'synced' ? 'SYNCED' :
+        detail.status === 'error' ? `ERREUR (${detail.error})` : 'deja a jour';
+      console.log(`  ${symbol} ${detail.file} \u2192 ${suffix}`);
+    }
+
+    console.log(`\n  ${results.total} fichiers scannes, ${results.synced} synchronises, ${results.unchanged} inchanges.`);
+    if (results.errors > 0) console.log(`  ${results.errors} erreurs.`);
+    console.log('');
+  } catch (err) {
+    spinner.fail('Erreur sync');
+    console.error(`  ${err.message}\n`);
+  }
+}
+
+async function handleStatus(flags, config) {
+  const diag = await diagnoseHcm();
+
+  if (flags.format === 'json') {
+    console.log(formatOutput(diag, 'json'));
+    return;
+  }
+
+  console.log(`\n  URL : ${diag.url}`);
+  for (const check of diag.checks) {
+    const symbol = check.ok ? '\u2713' : '\u2717';
+    console.log(`  ${symbol} ${check.label} : ${check.detail}`);
+  }
+
+  const { detectProject } = await import('../../lib/core/project.js');
+  const project = detectProject(config.cwd);
+  if (project) {
+    console.log(`\n  Projet ${style.bold(project.id)} detecte localement`);
+  }
+  console.log('');
+}
+
+async function handleSearch(args, flags, _config) {
+  let query = args.join(' ');
+
+  // If no query → ask interactively
+  if (!query) {
+    query = await askText('Recherche HCM');
+    if (!query) return;
+  }
+
+  const client = createHcmClient();
+
+  try {
+    const results = await client.search(query);
+
+    if (flags.format === 'json') {
+      console.log(formatOutput(results, 'json'));
+      return;
+    }
+
+    const items = results.results || results.documents || results || [];
+    if (!Array.isArray(items) || items.length === 0) {
+      console.log('\n  Aucun resultat.\n');
+      return;
+    }
+
+    console.log(`\n  ${items.length} resultats :\n`);
+    items.forEach((item, i) => {
+      const title = item.title || item.label || item.id || '(sans titre)';
+      const score = item.score ? ` (score: ${item.score.toFixed(1)})` : '';
+      console.log(`  ${i + 1}. ${title}${score}`);
+    });
+    console.log('');
+  } catch (err) {
+    console.error(`  Erreur HCM : ${err.message}\n`);
+  }
+}