@arka-labs/nemesis 1.2.0

package/lib/sync/hcm-client.js

@@ -0,0 +1,170 @@
+/**
+ * HCM API client — vanilla fetch (Node 20+), zero deps.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { debug } from '../core/logger.js';
+
+function loadSavedAuth() {
+  const configFile = join(homedir(), '.nemesis', 'config.json');
+  if (!existsSync(configFile)) return {};
+  try {
+    return JSON.parse(readFileSync(configFile, 'utf-8'));
+  } catch (e) {
+    debug(`loadSavedAuth: ${e.message}`);
+    return {};
+  }
+}
+
+export function createHcmClient(opts = {}) {
+  const saved = loadSavedAuth();
+  const {
+    baseUrl = saved.hcm_url || process.env.HCM_URL || 'https://hcm.arkalabs.app',
+    apiKey = saved.hcm_api_key || process.env.HCM_API_KEY || '',
+    timeout = 10000,
+  } = opts;
+
+  // Detect if a different fallback key exists (env vs config)
+  const envKey = process.env.HCM_API_KEY || '';
+  const configKey = saved.hcm_api_key || '';
+  const fallbackKey = (!opts.apiKey && envKey && configKey && envKey !== configKey) ? configKey : '';
+
+  let activeKey = apiKey;
+
+  function buildHeaders(key) {
+    return {
+      'Content-Type': 'application/json',
+      ...(key ? { 'X-API-Key': key } : {}),
+    };
+  }
+
+  async function doFetch(method, url, key, body, signal) {
+    const res = await fetch(url, {
+      method,
+      headers: buildHeaders(key),
+      body: body ? JSON.stringify(body) : null,
+      signal,
+    });
+    return res;
+  }
+
+  async function request(method, path, body = null) {
+    const url = `${baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      let res = await doFetch(method, url, activeKey, body, controller.signal);
+
+      // 401 + fallback key available → retry with fallback
+      if (res.status === 401 && fallbackKey && activeKey !== fallbackKey) {
+        activeKey = fallbackKey;
+        res = await doFetch(method, url, activeKey, body, controller.signal);
+      }
+
+      clearTimeout(timer);
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`HCM API ${res.status}: ${text || res.statusText}`);
+      }
+
+      const contentType = res.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) {
+        const json = await res.json();
+        if (json && typeof json === 'object' && json.ok === true && 'data' in json) {
+          return json.data;
+        }
+        return json;
+      }
+      return await res.text();
+    } catch (err) {
+      clearTimeout(timer);
+      if (err.name === 'AbortError') {
+        throw new Error(`HCM API timeout (${timeout}ms) : ${url}`, { cause: err });
+      }
+      throw err;
+    }
+  }
+
+  return {
+    baseUrl,
+
+    async health() {
+      return request('GET', '/health');
+    },
+
+    async graphStats() {
+      return request('GET', '/status');
+    },
+
+    async search(query, opts = {}) {
+      return request('POST', '/api/v1/documents/search', {
+        text_query: query,
+        limit: opts.limit || 10,
+        tags: opts.tags || [],
+      });
+    },
+
+    async listProfiles() {
+      const res = await request('GET', '/profiles');
+      return Array.isArray(res) ? res : (res?.profiles || []);
+    },
+
+    async listProfilesSummary() {
+      const res = await request('GET', '/profiles/summary');
+      return Array.isArray(res) ? res : [];
+    },
+
+    async getProfileAtoms(profileId, sousFamilles = []) {
+      const params = sousFamilles.length > 0
+        ? `?sous_famille=${sousFamilles.join(',')}`
+        : '';
+      const res = await request('GET', `/profiles/${profileId}/atoms${params}`);
+      // Handle {atoms: [...]} (envelope) or direct array (legacy)
+      return Array.isArray(res) ? res : (res?.atoms || []);
+    },
+
+    async searchAtoms(opts = {}) {
+      const params = new URLSearchParams();
+      if (opts.sousFamille) params.set('sous_famille', opts.sousFamille);
+      if (opts.type) params.set('type', opts.type);
+      if (opts.limit) params.set('limit', String(opts.limit));
+      const qs = params.toString();
+      const res = await request('GET', `/api/v1/atoms/search${qs ? '?' + qs : ''}`);
+      return res?.atoms || (Array.isArray(res) ? res : []);
+    },
+
+    async searchProfiles(q, sector) {
+      const params = new URLSearchParams();
+      if (q) params.set('q', q);
+      if (sector) params.set('sector', sector);
+      const qs = params.toString();
+      return request('GET', `/profiles/search${qs ? '?' + qs : ''}`);
+    },
+
+    async buildKairosPack(profileId, opts = {}) {
+      return request('POST', '/kairos/pack', {
+        profileId,
+        include_governance: opts.includeGovernance ?? true,
+        sous_familles: opts.sousFamilles || [],
+      });
+    },
+
+    async deposit(node) {
+      return request('POST', '/api/v1/deposit', node);
+    },
+
+    async ping() {
+      const start = Date.now();
+      try {
+        await request('GET', '/health');
+        return { ok: true, latency: Date.now() - start };
+      } catch (err) {
+        return { ok: false, latency: Date.now() - start, error: err.message };
+      }
+    },
+  };
+}

package/lib/sync/health.js

@@ -0,0 +1,47 @@
+import { createHcmClient } from './hcm-client.js';
+
+/**
+ * Run full health diagnostic on HCM connection.
+ */
+export async function diagnoseHcm(opts = {}) {
+  const client = createHcmClient(opts);
+  const checks = [];
+
+  // Check 1: Ping
+  const pingResult = await client.ping();
+  checks.push({
+    label: 'Connexion',
+    ok: pingResult.ok,
+    detail: pingResult.ok
+      ? `${pingResult.latency}ms`
+      : pingResult.error,
+  });
+
+  if (!pingResult.ok) {
+    return { ok: false, checks, url: client.baseUrl };
+  }
+
+  // Check 2: Auth
+  try {
+    await client.health();
+    checks.push({ label: 'Auth', ok: true, detail: 'API key valide' });
+  } catch (err) {
+    checks.push({ label: 'Auth', ok: false, detail: err.message });
+    return { ok: false, checks, url: client.baseUrl };
+  }
+
+  // Check 3: Graph stats
+  try {
+    const stats = await client.graphStats();
+    checks.push({
+      label: 'Graphe',
+      ok: true,
+      detail: `${stats.node_count ?? '?'} noeuds, ${stats.edge_count ?? '?'} edges`,
+    });
+  } catch (err) {
+    checks.push({ label: 'Graphe', ok: false, detail: err.message });
+  }
+
+  const allOk = checks.every(c => c.ok);
+  return { ok: allOk, checks, url: client.baseUrl };
+}

package/lib/sync/llm-client.js

@@ -0,0 +1,387 @@
+import { execFileSync } from 'node:child_process';
+import { getConnexionCredential } from '../core/connexions.js';
+import { debug } from '../core/logger.js';
+
+const PROVIDER_DEFAULTS = {
+  anthropic:    { baseUrl: 'https://api.anthropic.com',       healthPath: '/v1/messages', method: 'POST' },
+  openai:       { baseUrl: 'https://api.openai.com',          healthPath: '/v1/models',   method: 'GET'  },
+  gemini_genai: { baseUrl: 'https://generativelanguage.googleapis.com', healthPath: '/v1beta/models', method: 'GET' },
+  google_cloud: { baseUrl: 'https://us-central1-aiplatform.googleapis.com', healthPath: null, method: 'GET' },
+  aws_bedrock:  { baseUrl: null, healthPath: null, method: 'GET' },
+  ollama:       { baseUrl: 'http://localhost:11434',           healthPath: '/api/tags',    method: 'GET'  },
+  groq:         { baseUrl: 'https://api.groq.com',            healthPath: '/openai/v1/models', method: 'GET' },
+  custom:       { baseUrl: null, healthPath: null, method: 'GET' },
+  cli_tools:    { baseUrl: null, healthPath: null, method: null },
+};
+
+export async function testConnection(connexion) {
+  const start = Date.now();
+  try {
+    if (connexion.provider === 'cli_tools') return testCliTools();
+    const credential = getConnexionCredential(connexion.id);
+    const defaults = PROVIDER_DEFAULTS[connexion.provider] || PROVIDER_DEFAULTS.custom;
+    const baseUrl = connexion.endpoint || defaults.baseUrl;
+    if (!baseUrl) return { ok: false, latency: 0, error: 'Endpoint non configure' };
+    const result = await testProvider(connexion.provider, baseUrl, credential, connexion.model);
+    return { ok: result.ok, latency: Date.now() - start, details: result.details, error: result.error || null };
+  } catch (err) {
+    return { ok: false, latency: Date.now() - start, error: err.message };
+  }
+}
+
+function testCliTools() {
+  try {
+    execFileSync('which', ['claude'], { stdio: 'pipe' });
+    return { ok: true, latency: 0, details: 'claude CLI disponible' };
+  } catch (e) {
+    debug(`testCliTools: ${e.message}`);
+    return { ok: false, latency: 0, error: 'claude CLI introuvable' };
+  }
+}
+
+async function testProvider(provider, baseUrl, credential, model) {
+  switch (provider) {
+    case 'anthropic':    return testAnthropic(baseUrl, credential, model);
+    case 'openai':       return testOpenAI(baseUrl, credential);
+    case 'groq':         return testOpenAI(baseUrl + '/openai', credential);
+    case 'gemini_genai': return testGemini(baseUrl, credential);
+    case 'ollama':       return testOllama(baseUrl);
+    default:             return testGeneric(baseUrl, credential);
+  }
+}
+
+async function testAnthropic(baseUrl, apiKey, model) {
+  const res = await fetch(`${baseUrl}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey || '',
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: model || 'claude-haiku-4-5-20251001',
+      max_tokens: 1,
+      messages: [{ role: 'user', content: 'ping' }],
+    }),
+    signal: AbortSignal.timeout(8000),
+  });
+  // 200 or 400 = auth OK (400 can be model not found but auth passed)
+  if (res.status === 200 || res.status === 400) {
+    return { ok: true, details: `HTTP ${res.status}` };
+  }
+  return { ok: false, error: `HTTP ${res.status}` };
+}
+
+async function testOpenAI(baseUrl, apiKey) {
+  const res = await fetch(`${baseUrl}/v1/models`, {
+    method: 'GET',
+    headers: { 'Authorization': `Bearer ${apiKey || ''}` },
+    signal: AbortSignal.timeout(8000),
+  });
+  if (res.ok) return { ok: true, details: `HTTP ${res.status}` };
+  return { ok: false, error: `HTTP ${res.status}` };
+}
+
+async function testGemini(baseUrl, apiKey) {
+  const res = await fetch(`${baseUrl}/v1beta/models?key=${apiKey || ''}`, {
+    method: 'GET',
+    signal: AbortSignal.timeout(8000),
+  });
+  if (res.ok) return { ok: true, details: `HTTP ${res.status}` };
+  return { ok: false, error: `HTTP ${res.status}` };
+}
+
+async function testOllama(baseUrl) {
+  const res = await fetch(`${baseUrl}/api/tags`, {
+    method: 'GET',
+    signal: AbortSignal.timeout(5000),
+  });
+  if (res.ok) return { ok: true, details: `HTTP ${res.status}` };
+  return { ok: false, error: `HTTP ${res.status}` };
+}
+
+async function testGeneric(baseUrl, credential) {
+  const headers = {};
+  if (credential) headers['Authorization'] = `Bearer ${credential}`;
+  const res = await fetch(baseUrl, {
+    method: 'GET',
+    headers,
+    signal: AbortSignal.timeout(8000),
+  });
+  if (res.ok) return { ok: true, details: `HTTP ${res.status}` };
+  return { ok: false, error: `HTTP ${res.status}` };
+}
+
+// ── Live test — vrai appel LLM ──────────────────────────────────────
+
+const LIVE_PROMPT = 'Reponds exactement : "Nemesis OK"';
+const LIVE_TIMEOUT = 15000;
+const CLI_LIVE_TIMEOUT = 60000;
+
+export async function liveTestConnection(connexion) {
+  const start = Date.now();
+  try {
+    if (connexion.provider === 'cli_tools') return liveTestCli(connexion);
+    const credential = getConnexionCredential(connexion.id);
+    const defaults = PROVIDER_DEFAULTS[connexion.provider] || PROVIDER_DEFAULTS.custom;
+    const baseUrl = connexion.endpoint || defaults.baseUrl;
+    if (!baseUrl) return { ok: false, latency: 0, response: null, error: 'Endpoint non configure' };
+
+    const result = await liveCallProvider(connexion.provider, baseUrl, credential, connexion.model);
+    return {
+      ok: result.ok,
+      latency: Date.now() - start,
+      response: result.response || null,
+      model: result.model || connexion.model || null,
+      error: result.error || null,
+    };
+  } catch (err) {
+    return { ok: false, latency: Date.now() - start, response: null, error: err.message };
+  }
+}
+
+async function liveCallProvider(provider, baseUrl, credential, model) {
+  switch (provider) {
+    case 'anthropic':    return liveAnthropic(baseUrl, credential, model);
+    case 'openai':       return liveOpenAI(baseUrl, credential, model);
+    case 'groq':         return liveOpenAI(baseUrl + '/openai', credential, model);
+    case 'gemini_genai': return liveGemini(baseUrl, credential, model);
+    case 'ollama':       return liveOllama(baseUrl, model);
+    default:             return { ok: false, error: 'Live test non supporte pour ce provider' };
+  }
+}
+
+async function liveAnthropic(baseUrl, apiKey, model) {
+  const res = await fetch(`${baseUrl}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey || '',
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: model || 'claude-haiku-4-5-20251001',
+      max_tokens: 50,
+      messages: [{ role: 'user', content: LIVE_PROMPT }],
+    }),
+    signal: AbortSignal.timeout(LIVE_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    return { ok: false, error: `HTTP ${res.status} — ${body.slice(0, 200)}` };
+  }
+  const data = await res.json();
+  const text = data.content?.[0]?.text || '';
+  return { ok: true, response: text, model: data.model || model };
+}
+
+async function liveOpenAI(baseUrl, apiKey, model) {
+  const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey || ''}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: model || 'gpt-4o-mini',
+      max_tokens: 50,
+      messages: [{ role: 'user', content: LIVE_PROMPT }],
+    }),
+    signal: AbortSignal.timeout(LIVE_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    return { ok: false, error: `HTTP ${res.status} — ${body.slice(0, 200)}` };
+  }
+  const data = await res.json();
+  const text = data.choices?.[0]?.message?.content || '';
+  return { ok: true, response: text, model: data.model || model };
+}
+
+async function liveGemini(baseUrl, apiKey, model) {
+  const m = model || 'gemini-2.0-flash';
+  const res = await fetch(`${baseUrl}/v1beta/models/${m}:generateContent?key=${apiKey || ''}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      contents: [{ parts: [{ text: LIVE_PROMPT }] }],
+    }),
+    signal: AbortSignal.timeout(LIVE_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    return { ok: false, error: `HTTP ${res.status} — ${body.slice(0, 200)}` };
+  }
+  const data = await res.json();
+  const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+  return { ok: true, response: text, model: m };
+}
+
+async function liveOllama(baseUrl, model) {
+  const res = await fetch(`${baseUrl}/api/generate`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      model: model || 'llama3',
+      prompt: LIVE_PROMPT,
+      stream: false,
+    }),
+    signal: AbortSignal.timeout(LIVE_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    return { ok: false, error: `HTTP ${res.status} — ${body.slice(0, 200)}` };
+  }
+  const data = await res.json();
+  return { ok: true, response: data.response || '', model: data.model || model };
+}
+
+// ── API call — system + user prompt ─────────────────────────────────
+
+const API_CALL_TIMEOUT = 30000;
+
+/**
+ * Make an actual LLM API call with system + user prompts.
+ * Used by createServiceCaller for NoteWriter integration.
+ * @param {object} connexion - { provider, endpoint, ... }
+ * @param {string} credential - API key
+ * @param {string} model - Model identifier
+ * @param {string} systemPrompt
+ * @param {string} userPrompt
+ * @returns {Promise<string>} Response text
+ */
+export async function callLlmApi(connexion, credential, model, systemPrompt, userPrompt) {
+  const defaults = PROVIDER_DEFAULTS[connexion.provider] || PROVIDER_DEFAULTS.custom;
+  const baseUrl = connexion.endpoint || defaults.baseUrl;
+  if (!baseUrl) throw new Error('Endpoint non configure');
+
+  switch (connexion.provider) {
+    case 'anthropic':    return callAnthropic(baseUrl, credential, model, systemPrompt, userPrompt);
+    case 'openai':       return callOpenAI(baseUrl, credential, model, systemPrompt, userPrompt);
+    case 'groq':         return callOpenAI(baseUrl + '/openai', credential, model || 'llama-3.3-70b-versatile', systemPrompt, userPrompt);
+    case 'gemini_genai': return callGemini(baseUrl, credential, model, systemPrompt, userPrompt);
+    case 'ollama':       return callOllama(baseUrl, model, systemPrompt, userPrompt);
+    default:             throw new Error(`Provider "${connexion.provider}" non supporte pour les appels LLM`);
+  }
+}
+
+async function callAnthropic(baseUrl, apiKey, model, systemPrompt, userPrompt) {
+  const res = await fetch(`${baseUrl}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey || '',
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: model || 'claude-haiku-4-5-20251001',
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userPrompt }],
+    }),
+    signal: AbortSignal.timeout(API_CALL_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    const err = new Error(`HTTP ${res.status} — ${body.slice(0, 200)}`);
+    err.status = res.status;
+    throw err;
+  }
+  const data = await res.json();
+  return data.content?.[0]?.text || '';
+}
+
+async function callOpenAI(baseUrl, apiKey, model, systemPrompt, userPrompt) {
+  const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey || ''}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: model || 'gpt-4o-mini',
+      max_tokens: 4096,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+    }),
+    signal: AbortSignal.timeout(API_CALL_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    const err = new Error(`HTTP ${res.status} — ${body.slice(0, 200)}`);
+    err.status = res.status;
+    throw err;
+  }
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+async function callGemini(baseUrl, apiKey, model, systemPrompt, userPrompt) {
+  const m = model || 'gemini-2.0-flash';
+  const res = await fetch(`${baseUrl}/v1beta/models/${m}:generateContent?key=${apiKey || ''}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      systemInstruction: { parts: [{ text: systemPrompt }] },
+      contents: [{ parts: [{ text: userPrompt }] }],
+    }),
+    signal: AbortSignal.timeout(API_CALL_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    const err = new Error(`HTTP ${res.status} — ${body.slice(0, 200)}`);
+    err.status = res.status;
+    throw err;
+  }
+  const data = await res.json();
+  return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+}
+
+async function callOllama(baseUrl, model, systemPrompt, userPrompt) {
+  const res = await fetch(`${baseUrl}/api/generate`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      model: model || 'llama3',
+      system: systemPrompt,
+      prompt: userPrompt,
+      stream: false,
+    }),
+    signal: AbortSignal.timeout(API_CALL_TIMEOUT),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    const err = new Error(`HTTP ${res.status} — ${body.slice(0, 200)}`);
+    err.status = res.status;
+    throw err;
+  }
+  const data = await res.json();
+  return data.response || '';
+}
+
+function liveTestCli(connexion = {}) {
+  try {
+    const args = [
+      '-p', LIVE_PROMPT,
+      '--output-format', 'json',
+      '--dangerously-skip-permissions',
+    ];
+    if (connexion.model) args.push('--model', connexion.model);
+
+    const result = execFileSync('claude', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: CLI_LIVE_TIMEOUT,
+      encoding: 'utf-8',
+    });
+    let text = result;
+    try {
+      const parsed = JSON.parse(result);
+      text = parsed.result || parsed.text || result;
+    } catch (e) { debug(`callCliTool parse: ${e.message}`); }
+    return { ok: true, latency: 0, response: text, model: connexion.model || 'claude-cli' };
+  } catch (err) {
+    return { ok: false, latency: 0, response: null, error: err.message };
+  }
+}