nothumanallowed 1.1.0 → 2.1.0

package/src/services/llm.mjs

@@ -0,0 +1,319 @@
+/**
+ * Shared LLM provider service — zero dependencies.
+ * Used by both `nha ask` (interactive) and PAO pipeline (batch).
+ *
+ * Supports: Anthropic, OpenAI, Gemini, DeepSeek, Grok, Mistral, Cohere.
+ */
+
+// ── Providers ──────────────────────────────────────────────────────────────
+
+export async function callAnthropic(apiKey, model, systemPrompt, userMessage, stream = false) {
+  const body = {
+    model: model || 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    system: systemPrompt,
+    messages: [{ role: 'user', content: userMessage }],
+    stream,
+  };
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Anthropic ${res.status}: ${err}`);
+  }
+  if (stream) return streamSSE(res, 'anthropic');
+  const data = await res.json();
+  return data.content?.[0]?.text || '';
+}
+
+export async function callOpenAI(apiKey, model, systemPrompt, userMessage, stream = false) {
+  const body = {
+    model: model || 'gpt-4o',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`OpenAI ${res.status}: ${err}`);
+  }
+  if (stream) return streamSSE(res, 'openai');
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+export async function callGemini(apiKey, model, systemPrompt, userMessage, _stream = false) {
+  const m = model || 'gemini-2.5-pro-preview-05-06';
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${m}:generateContent?key=${apiKey}`;
+  const body = {
+    system_instruction: { parts: [{ text: systemPrompt }] },
+    contents: [{ parts: [{ text: userMessage }] }],
+    generationConfig: { maxOutputTokens: 8192 },
+  };
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Gemini ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+}
+
+export async function callDeepSeek(apiKey, model, systemPrompt, userMessage, stream = false) {
+  const body = {
+    model: model || 'deepseek-chat',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+  const res = await fetch('https://api.deepseek.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`DeepSeek ${res.status}: ${err}`);
+  }
+  if (stream) return streamSSE(res, 'openai');
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+export async function callGrok(apiKey, model, systemPrompt, userMessage, stream = false) {
+  const body = {
+    model: model || 'grok-3-latest',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+  const res = await fetch('https://api.x.ai/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Grok ${res.status}: ${err}`);
+  }
+  if (stream) return streamSSE(res, 'openai');
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+export async function callMistral(apiKey, model, systemPrompt, userMessage, stream = false) {
+  const body = {
+    model: model || 'mistral-large-latest',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+  const res = await fetch('https://api.mistral.ai/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Mistral ${res.status}: ${err}`);
+  }
+  if (stream) return streamSSE(res, 'openai');
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+export async function callCohere(apiKey, model, systemPrompt, userMessage, _stream = false) {
+  const body = {
+    model: model || 'command-r-plus',
+    max_tokens: 8192,
+    preamble: systemPrompt,
+    message: userMessage,
+  };
+  const res = await fetch('https://api.cohere.ai/v1/chat', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Cohere ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  return data.text || '';
+}
+
+// ── SSE Stream Parser ──────────────────────────────────────────────────────
+
+export async function streamSSE(res, format) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') continue;
+
+      try {
+        const json = JSON.parse(data);
+        let chunk = '';
+
+        if (format === 'anthropic') {
+          if (json.type === 'content_block_delta') {
+            chunk = json.delta?.text || '';
+          }
+        } else {
+          chunk = json.choices?.[0]?.delta?.content || '';
+        }
+
+        if (chunk) {
+          process.stdout.write(chunk);
+          fullText += chunk;
+        }
+      } catch {}
+    }
+  }
+
+  process.stdout.write('\n');
+  return fullText;
+}
+
+// ── Router ─────────────────────────────────────────────────────────────────
+
+const PROVIDERS = {
+  anthropic: callAnthropic,
+  openai: callOpenAI,
+  gemini: callGemini,
+  deepseek: callDeepSeek,
+  grok: callGrok,
+  mistral: callMistral,
+  cohere: callCohere,
+};
+
+export function getProviderCall(provider) {
+  return PROVIDERS[provider] || null;
+}
+
+export function getApiKey(config, provider) {
+  const keyMap = {
+    anthropic: config.llm.apiKey,
+    openai: config.llm.openaiKey || config.llm.apiKey,
+    gemini: config.llm.geminiKey || config.llm.apiKey,
+    deepseek: config.llm.deepseekKey || config.llm.apiKey,
+    grok: config.llm.grokKey || config.llm.apiKey,
+    mistral: config.llm.mistralKey || config.llm.apiKey,
+    cohere: config.llm.cohereKey || config.llm.apiKey,
+  };
+  return keyMap[provider] || config.llm.apiKey;
+}
+
+/**
+ * Call an LLM provider with the given prompt. No streaming.
+ * @returns {Promise<string>} The LLM response text.
+ */
+export async function callLLM(config, systemPrompt, userMessage, opts = {}) {
+  const provider = opts.provider || config.llm.provider || 'anthropic';
+  const model = opts.model || config.llm.model || null;
+  const apiKey = getApiKey(config, provider);
+  if (!apiKey) throw new Error(`No API key for ${provider}`);
+
+  const callFn = getProviderCall(provider);
+  if (!callFn) throw new Error(`Unknown provider: ${provider}`);
+
+  return callFn(apiKey, model, systemPrompt, userMessage, false);
+}
+
+/**
+ * Call an agent by name — loads the agent file, calls LLM, returns response.
+ * No streaming. Used by PAO pipeline for batch agent calls.
+ */
+export async function callAgent(config, agentName, userMessage, opts = {}) {
+  const { AGENTS_DIR } = await import('../constants.mjs');
+  const fs = await import('fs');
+  const path = await import('path');
+
+  const agentFile = path.default.join(AGENTS_DIR, `${agentName}.mjs`);
+  if (!fs.default.existsSync(agentFile)) throw new Error(`Agent ${agentName} not found`);
+
+  const source = fs.default.readFileSync(agentFile, 'utf-8');
+  const { systemPrompt } = parseAgentFile(source, agentName);
+  if (!systemPrompt) throw new Error(`Agent ${agentName} has no SYSTEM_PROMPT`);
+
+  return callLLM(config, systemPrompt, userMessage, opts);
+}
+
+// ── Agent File Parser (shared) ─────────────────────────────────────────────
+
+export function parseAgentFile(source, agentName) {
+  let card = { displayName: agentName.toUpperCase(), category: 'agent', tagline: '' };
+  let systemPrompt = '';
+
+  const cardMatch = source.match(/export\s+var\s+AGENT_CARD\s*=\s*(\{[\s\S]*?\});/);
+  if (cardMatch) {
+    try { card = new Function('return ' + cardMatch[1])(); } catch {}
+  }
+
+  const promptMatch = source.match(/export\s+var\s+SYSTEM_PROMPT\s*=\s*([\s\S]*?);(?:\n\nexport|\n\nvar|\n\n\/\/)/);
+  if (promptMatch) {
+    try { systemPrompt = new Function('return ' + promptMatch[1])(); } catch {}
+  }
+
+  if (!systemPrompt) {
+    const simpleMatch = source.match(/SYSTEM_PROMPT\s*=\s*'([\s\S]*?)';/);
+    if (simpleMatch) systemPrompt = simpleMatch[1];
+  }
+
+  return { card, systemPrompt };
+}

package/src/services/notification.mjs

@@ -0,0 +1,109 @@
+/**
+ * Desktop + webhook notifications — zero dependencies.
+ * macOS: osascript, Linux: notify-send, Webhooks: fetch POST
+ */
+
+import { execSync } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { NHA_DIR } from '../constants.mjs';
+
+const LOG_FILE = path.join(NHA_DIR, 'ops', 'daemon', 'notifications.log');
+
+/**
+ * Send a notification via all configured channels.
+ * @param {string} title
+ * @param {string} body
+ * @param {object} config — NHA config
+ */
+export async function notify(title, body, config) {
+  const ops = config.ops || {};
+  const notifs = ops.notifications || {};
+
+  // Desktop notification
+  if (notifs.desktop !== false) {
+    sendDesktop(title, body);
+  }
+
+  // Terminal log
+  if (notifs.terminal !== false) {
+    logToFile(title, body);
+  }
+
+  // Telegram webhook
+  if (ops.webhooks?.telegram) {
+    sendTelegram(ops.webhooks.telegram, title, body).catch(() => {});
+  }
+
+  // Discord webhook
+  if (ops.webhooks?.discord) {
+    sendDiscord(ops.webhooks.discord, title, body).catch(() => {});
+  }
+}
+
+function sendDesktop(title, body) {
+  const platform = os.platform();
+  try {
+    if (platform === 'darwin') {
+      const escaped = body.replace(/"/g, '\\"').slice(0, 200);
+      execSync(`osascript -e 'display notification "${escaped}" with title "NHA: ${title.replace(/"/g, '\\"')}"'`);
+    } else if (platform === 'linux') {
+      execSync(`notify-send "NHA: ${title}" "${body.slice(0, 200)}"`);
+    }
+    // Windows: PowerShell toast (best effort)
+    else if (platform === 'win32') {
+      execSync(`powershell -Command "New-BurntToastNotification -Text 'NHA: ${title}', '${body.slice(0, 200)}'" 2>NUL`);
+    }
+  } catch { /* non-fatal */ }
+}
+
+function logToFile(title, body) {
+  const dir = path.dirname(LOG_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${title}: ${body}\n`;
+  fs.appendFileSync(LOG_FILE, line, { mode: 0o600 });
+
+  // Rotate if > 1MB
+  try {
+    const stat = fs.statSync(LOG_FILE);
+    if (stat.size > 1_048_576) {
+      const rotated = LOG_FILE + '.1';
+      if (fs.existsSync(rotated)) fs.rmSync(rotated);
+      fs.renameSync(LOG_FILE, rotated);
+    }
+  } catch {}
+}
+
+async function sendTelegram(config, title, body) {
+  // config format: "botToken:chatId" or { botToken, chatId }
+  let botToken, chatId;
+  if (typeof config === 'string') {
+    [botToken, chatId] = config.split(':');
+  } else {
+    botToken = config.botToken;
+    chatId = config.chatId;
+  }
+  if (!botToken || !chatId) return;
+
+  await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      chat_id: chatId,
+      text: `*NHA: ${title}*\n${body}`,
+      parse_mode: 'Markdown',
+    }),
+  });
+}
+
+async function sendDiscord(webhookUrl, title, body) {
+  await fetch(webhookUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      content: `**NHA: ${title}**\n${body}`,
+    }),
+  });
+}

package/src/services/ops-daemon.mjs

@@ -0,0 +1,247 @@
+/**
+ * PAO Background Daemon — watches Gmail + Calendar, triggers agents.
+ *
+ * Runs as detached child process. Polls every 5 min (mail), 15 min (calendar).
+ * Generates daily plan at configured time. Sends notifications.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { NHA_DIR } from '../constants.mjs';
+import { loadConfig } from '../config.mjs';
+import { loadTokens } from './token-store.mjs';
+import { getUnreadImportant } from './google-gmail.mjs';
+import { getUpcomingEvents } from './google-calendar.mjs';
+import { notify } from './notification.mjs';
+import { callAgent } from './llm.mjs';
+import { runPlanningPipeline } from './ops-pipeline.mjs';
+
+const DAEMON_DIR = path.join(NHA_DIR, 'ops', 'daemon');
+const PID_FILE = path.join(DAEMON_DIR, 'daemon.pid');
+const STATE_FILE = path.join(DAEMON_DIR, 'state.json');
+const LOG_FILE = path.join(DAEMON_DIR, 'daemon.log');
+
+// ── Daemon Control ─────────────────────────────────────────────────────────
+
+/**
+ * Check if daemon is running.
+ */
+export function isRunning() {
+  if (!fs.existsSync(PID_FILE)) return false;
+  const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim());
+  try {
+    process.kill(pid, 0); // signal 0 = check if alive
+    return true;
+  } catch {
+    // PID file stale — clean up
+    fs.rmSync(PID_FILE, { force: true });
+    return false;
+  }
+}
+
+/**
+ * Start the daemon as a detached background process.
+ */
+export function startDaemon() {
+  if (isRunning()) {
+    return { ok: false, message: 'Daemon already running' };
+  }
+
+  fs.mkdirSync(DAEMON_DIR, { recursive: true });
+
+  // The daemon runs this same file with --daemon-loop flag
+  const logFd = fs.openSync(LOG_FILE, 'a');
+  const child = spawn(process.execPath, [
+    path.join(NHA_DIR, '..', 'packages', 'nha-cli', 'src', 'services', 'ops-daemon.mjs'),
+    '--daemon-loop',
+  ], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, NHA_DAEMON: '1' },
+  });
+
+  child.unref();
+  fs.writeFileSync(PID_FILE, String(child.pid), { mode: 0o600 });
+  fs.closeSync(logFd);
+
+  return { ok: true, pid: child.pid };
+}
+
+/**
+ * Stop the daemon.
+ */
+export function stopDaemon() {
+  if (!fs.existsSync(PID_FILE)) {
+    return { ok: false, message: 'No daemon running' };
+  }
+
+  const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim());
+  try {
+    process.kill(pid, 'SIGTERM');
+    fs.rmSync(PID_FILE, { force: true });
+    return { ok: true, pid };
+  } catch {
+    fs.rmSync(PID_FILE, { force: true });
+    return { ok: false, message: 'Daemon process not found (stale PID)' };
+  }
+}
+
+/**
+ * Get daemon status.
+ */
+export function getDaemonStatus() {
+  const running = isRunning();
+  let state = {};
+  if (fs.existsSync(STATE_FILE)) {
+    try { state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')); } catch {}
+  }
+  let pid = null;
+  if (fs.existsSync(PID_FILE)) {
+    pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim());
+  }
+  return { running, pid, ...state };
+}
+
+// ── Daemon Loop (runs in background process) ───────────────────────────────
+
+function saveState(state) {
+  fs.mkdirSync(DAEMON_DIR, { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  console.log(`[${ts}] ${msg}`);
+}
+
+async function daemonLoop() {
+  log('NHA PAO Daemon started');
+  const config = loadConfig();
+
+  const state = {
+    startedAt: new Date().toISOString(),
+    lastMailCheck: null,
+    lastCalendarCheck: null,
+    lastPlanGenerated: null,
+    errors: 0,
+  };
+  saveState(state);
+
+  const MAIL_INTERVAL = config.ops?.pollIntervalMail || 300_000;     // 5 min
+  const CAL_INTERVAL = config.ops?.pollIntervalCalendar || 900_000;  // 15 min
+  const MEETING_ALERT = config.ops?.meetingAlertMinutes || 30;
+  const PLAN_TIME = config.ops?.planTime || '07:00';
+
+  let lastMailCheck = 0;
+  let lastCalCheck = 0;
+  let todayPlanDone = false;
+  let knownEmailIds = new Set();
+
+  // Main loop
+  setInterval(async () => {
+    const now = Date.now();
+    const tokens = loadTokens();
+    if (!tokens) return; // not authenticated
+
+    // ── Mail check ─────────────────────────────────────────
+    if (now - lastMailCheck > MAIL_INTERVAL) {
+      lastMailCheck = now;
+      try {
+        const emails = await getUnreadImportant(config, 10);
+        const newEmails = emails.filter(e => !knownEmailIds.has(e.id));
+
+        for (const email of newEmails) {
+          knownEmailIds.add(email.id);
+
+          // SABER quick scan for suspicious emails
+          if (email.urls.length > 0 || email.from.includes('paypal') || email.from.includes('bank') || email.subject.toLowerCase().includes('urgent')) {
+            try {
+              const scanResult = await callAgent(config, 'saber',
+                `Quick security scan: From="${email.from}" Subject="${email.subject}" URLs=${email.urls.join(', ')}\nIs this potentially phishing? Respond: SAFE or FLAGGED with reason (one line).`
+              );
+              if (scanResult.toUpperCase().includes('FLAGGED')) {
+                await notify('Security Alert', `Suspicious email from ${email.from}: ${email.subject}\n${scanResult}`, config);
+              }
+            } catch { /* non-fatal */ }
+          }
+
+          // Notify about important new emails
+          if (email.isImportant) {
+            await notify('Important Email', `From: ${email.from}\n${email.subject}`, config);
+          }
+        }
+
+        state.lastMailCheck = new Date().toISOString();
+        saveState(state);
+        log(`Mail check: ${emails.length} unread, ${newEmails.length} new`);
+      } catch (err) {
+        state.errors++;
+        log(`Mail check error: ${err.message}`);
+      }
+    }
+
+    // ── Calendar check ─────────────────────────────────────
+    if (now - lastCalCheck > CAL_INTERVAL) {
+      lastCalCheck = now;
+      try {
+        const upcoming = await getUpcomingEvents(config, 1); // next 1 hour
+
+        for (const event of upcoming) {
+          const eventStart = new Date(event.start).getTime();
+          const minutesUntil = (eventStart - now) / 60000;
+
+          if (minutesUntil > 0 && minutesUntil <= MEETING_ALERT) {
+            // Generate quick brief with HERALD
+            try {
+              const brief = await callAgent(config, 'herald',
+                `Meeting in ${Math.round(minutesUntil)} minutes: "${event.summary}"\nAttendees: ${event.attendees.map(a => a.name || a.email).join(', ')}\nDescription: ${event.description.slice(0, 500)}\n\nGenerate a 3-sentence brief.`
+              );
+              await notify(`Meeting in ${Math.round(minutesUntil)}min`, `${event.summary}\n${brief}`, config);
+            } catch {
+              await notify(`Meeting in ${Math.round(minutesUntil)}min`, event.summary, config);
+            }
+          }
+        }
+
+        state.lastCalendarCheck = new Date().toISOString();
+        saveState(state);
+        log(`Calendar check: ${upcoming.length} upcoming events`);
+      } catch (err) {
+        state.errors++;
+        log(`Calendar check error: ${err.message}`);
+      }
+    }
+
+    // ── Daily plan generation ──────────────────────────────
+    const nowTime = new Date();
+    const currentTime = `${String(nowTime.getHours()).padStart(2, '0')}:${String(nowTime.getMinutes()).padStart(2, '0')}`;
+    const todayStr = nowTime.toISOString().split('T')[0];
+
+    if (!todayPlanDone && currentTime >= PLAN_TIME && currentTime < PLAN_TIME.replace(/:(\d+)/, (_, m) => ':' + String(Number(m) + 5).padStart(2, '0'))) {
+      todayPlanDone = true;
+      try {
+        log('Generating daily plan...');
+        await runPlanningPipeline(config, { date: todayStr, refresh: true });
+        state.lastPlanGenerated = new Date().toISOString();
+        saveState(state);
+        await notify('Daily Plan Ready', `Your plan for ${todayStr} is ready. Run "nha plan --show" to view.`, config);
+        log('Daily plan generated');
+      } catch (err) {
+        log(`Plan generation error: ${err.message}`);
+      }
+    }
+
+    // Reset plan flag at midnight
+    if (currentTime === '00:00') todayPlanDone = false;
+
+  }, 60_000); // Check every 60 seconds
+}
+
+// ── Direct execution (daemon mode) ─────────────────────────────────────────
+if (process.argv.includes('--daemon-loop')) {
+  daemonLoop().catch(err => {
+    console.error('Daemon fatal error:', err);
+    process.exit(1);
+  });
+}