nothumanallowed 4.1.0 → 6.0.0

package/src/config.mjs

@@ -52,6 +52,11 @@ const DEFAULT_CONFIG = {
     clientId: '',
     clientSecret: '',
   },
+  microsoft: {
+    clientId: '',
+    clientSecret: '',
+    tenantId: 'common',
+  },
   ops: {
     enabled: false,
     planTime: '07:00',
@@ -67,6 +72,33 @@ const DEFAULT_CONFIG = {
       desktop: true,
       terminal: true,
     },
+    proactive: {
+      enabled: true,
+      emailFollowUp: true,
+      meetingPrep: true,
+      patterns: true,
+      deadlines: true,
+    },
+  },
+  responder: {
+    autoRoute: true,
+    telegram: {
+      token: '',
+      allowedChatIds: [],
+    },
+    discord: {
+      token: '',
+      allowedChannelIds: [],
+    },
+  },
+  plugins: {
+    autoRun: true,
+    directory: '',
+  },
+  voice: {
+    preferWhisper: false,
+    speechSynthesis: true,
+    language: '',
   },
 };
 
@@ -174,11 +206,28 @@ export function setConfigValue(key, value) {
     'knowledge': 'features.knowledgeEnabled',
     'google-client-id': 'google.clientId',
     'google-client-secret': 'google.clientSecret',
+    'microsoft-client-id': 'microsoft.clientId',
+    'microsoft-client-secret': 'microsoft.clientSecret',
+    'microsoft-tenant': 'microsoft.tenantId',
+    'microsoft-tenant-id': 'microsoft.tenantId',
     'plan-time': 'ops.planTime',
     'summary-time': 'ops.summaryTime',
     'meeting-alert': 'ops.meetingAlertMinutes',
     'telegram-webhook': 'ops.webhooks.telegram',
     'discord-webhook': 'ops.webhooks.discord',
+    'plugin-autorun': 'plugins.autoRun',
+    'plugin-dir': 'plugins.directory',
+    'voice-whisper': 'voice.preferWhisper',
+    'voice-speech': 'voice.speechSynthesis',
+    'voice-language': 'voice.language',
+    'telegram-bot-token': 'responder.telegram.token',
+    'discord-bot-token': 'responder.discord.token',
+    'responder-auto-route': 'responder.autoRoute',
+    'proactive': 'ops.proactive.enabled',
+    'proactive-email': 'ops.proactive.emailFollowUp',
+    'proactive-meeting': 'ops.proactive.meetingPrep',
+    'proactive-patterns': 'ops.proactive.patterns',
+    'proactive-deadlines': 'ops.proactive.deadlines',
   };
 
   const resolved = aliases[key] || key;
@@ -199,6 +248,18 @@ export function setConfigValue(key, value) {
     obj[lastKey] = value === 'true' || value === '1' || value === 'yes';
   } else if (typeof existing === 'number') {
     obj[lastKey] = Number(value);
+  } else if (Array.isArray(existing)) {
+    // Parse comma-separated values or JSON array
+    try {
+      const parsed = JSON.parse(value);
+      obj[lastKey] = Array.isArray(parsed) ? parsed : [parsed];
+    } catch {
+      obj[lastKey] = value.split(',').map(v => {
+        const trimmed = v.trim();
+        const num = Number(trimmed);
+        return !isNaN(num) && trimmed !== '' ? num : trimmed;
+      }).filter(Boolean);
+    }
   } else {
     obj[lastKey] = value;
   }

package/src/constants.mjs

@@ -1,7 +1,11 @@
 import os from 'os';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
-export const VERSION = '3.1.0';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const VERSION = '6.0.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 
@@ -9,6 +13,7 @@ export const NHA_DIR = path.join(os.homedir(), '.nha');
 export const CORE_DIR = path.join(NHA_DIR, 'core');
 export const AGENTS_DIR = path.join(NHA_DIR, 'agents');
 export const EXTENSIONS_DIR = path.join(NHA_DIR, 'extensions');
+export const PLUGINS_DIR = path.join(NHA_DIR, 'plugins');
 export const SESSIONS_DIR = path.join(NHA_DIR, 'sessions');
 export const MEMORY_DIR = path.join(NHA_DIR, 'memory');
 export const CONFIG_FILE = path.join(NHA_DIR, 'config.json');
@@ -18,6 +23,9 @@ export const PIF_FILE = path.join(CORE_DIR, 'pif.mjs');
 export const VERSIONS_FILE = path.join(CORE_DIR, 'versions.json');
 export const LAST_UPDATE_CHECK = path.join(CORE_DIR, '.last-update-check');
 
+/** Path to the daemon script within the installed npm package. */
+export const DAEMON_SCRIPT = path.resolve(path.join(__dirname, 'services', 'ops-daemon.mjs'));
+
 export const AGENTS = [
   'ade', 'athena', 'atlas', 'babel', 'cartographer', 'cassandra', 'conductor',
   'cron', 'echo', 'edi', 'epicure', 'flux', 'forge', 'glitch', 'heimdall',

package/src/services/llm.mjs

@@ -278,6 +278,9 @@ export async function callLLM(config, systemPrompt, userMessage, opts = {}) {
 /**
  * Call an agent by name — loads the agent file, calls LLM, returns response.
  * No streaming. Used by PAO pipeline for batch agent calls.
+ *
+ * Automatically injects relevant episodic memories into the prompt
+ * and extracts key facts from the response for future retrieval.
  */
 export async function callAgent(config, agentName, userMessage, opts = {}) {
   const { AGENTS_DIR } = await import('../constants.mjs');
@@ -291,7 +294,25 @@ export async function callAgent(config, agentName, userMessage, opts = {}) {
   const { systemPrompt } = parseAgentFile(source, agentName);
   if (!systemPrompt) throw new Error(`Agent ${agentName} has no SYSTEM_PROMPT`);
 
-  return callLLM(config, systemPrompt, userMessage, opts);
+  // ── Episodic Memory: inject relevant past interactions ──────────────────
+  let enrichedSystemPrompt = systemPrompt;
+  try {
+    const { buildMemoryContext } = await import('./memory.mjs');
+    const memoryContext = buildMemoryContext(agentName, userMessage);
+    if (memoryContext) {
+      enrichedSystemPrompt = systemPrompt + memoryContext;
+    }
+  } catch { /* memory unavailable — proceed without it */ }
+
+  const response = await callLLM(config, enrichedSystemPrompt, userMessage, opts);
+
+  // ── Episodic Memory: extract key facts from the interaction ─────────────
+  try {
+    const { extractMemory } = await import('./memory.mjs');
+    extractMemory(agentName, userMessage, response);
+  } catch { /* memory extraction failed — non-critical */ }
+
+  return response;
 }
 
 // ── Agent File Parser (shared) ─────────────────────────────────────────────

package/src/services/mail-router.mjs

@@ -0,0 +1,298 @@
+/**
+ * Unified Mail + Calendar router — routes to Google or Microsoft based on auth state.
+ *
+ * Detects which provider is authenticated and routes all mail/calendar calls
+ * through the appropriate service. If both are authenticated, prefers the
+ * provider specified in config, falling back to the first authenticated one.
+ *
+ * All functions return the same unified data shapes defined by google-gmail.mjs
+ * and google-calendar.mjs parsers (Microsoft services normalize to the same shape).
+ *
+ * Zero dependencies — pure routing layer.
+ */
+
+import { getAuthenticatedProviders, loadTokens } from './token-store.mjs';
+
+// Lazy imports to avoid loading both provider modules at startup
+let _google = null;
+let _microsoft = null;
+let _googleCal = null;
+let _microsoftCal = null;
+
+async function getGoogleMail() {
+  if (!_google) _google = await import('./google-gmail.mjs');
+  return _google;
+}
+
+async function getMicrosoftMail() {
+  if (!_microsoft) _microsoft = await import('./microsoft-mail.mjs');
+  return _microsoft;
+}
+
+async function getGoogleCalendar() {
+  if (!_googleCal) _googleCal = await import('./google-calendar.mjs');
+  return _googleCal;
+}
+
+async function getMicrosoftCalendar() {
+  if (!_microsoftCal) _microsoftCal = await import('./microsoft-calendar.mjs');
+  return _microsoftCal;
+}
+
+/**
+ * Determine which mail provider to use.
+ * @param {object} config — NHA config
+ * @returns {'google' | 'microsoft' | null}
+ */
+export function detectMailProvider(config) {
+  const providers = getAuthenticatedProviders();
+
+  // If a preferred provider is set in config and authenticated, use it
+  const preferred = config.ops?.mailProvider;
+  if (preferred && providers[preferred]) return preferred;
+
+  // Otherwise, use whichever is authenticated (Google first for backward compat)
+  if (providers.google) return 'google';
+  if (providers.microsoft) return 'microsoft';
+
+  return null;
+}
+
+/**
+ * Check if any mail provider is authenticated.
+ */
+export function hasMailProvider() {
+  const providers = getAuthenticatedProviders();
+  return providers.google || providers.microsoft;
+}
+
+/**
+ * Get authentication status for display purposes.
+ */
+export function getProviderStatus() {
+  const providers = getAuthenticatedProviders();
+  const result = [];
+
+  if (providers.google) {
+    const tokens = loadTokens('google');
+    result.push({ provider: 'google', email: tokens?.email || 'unknown', active: true });
+  }
+  if (providers.microsoft) {
+    const tokens = loadTokens('microsoft');
+    result.push({ provider: 'microsoft', email: tokens?.email || 'unknown', active: true });
+  }
+
+  return result;
+}
+
+// ── Mail Functions ─────────────────────────────────────────────────────────
+
+/**
+ * List messages matching a query.
+ */
+export async function listMessages(config, query = '', maxResults = 20) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated. Run: nha google auth OR nha microsoft auth');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.listMessages(config, query, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.listMessages(config, query || 'is:unread', maxResults);
+}
+
+/**
+ * Get a full message by ID.
+ */
+export async function getMessage(config, messageId) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getMessage(config, messageId);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getMessage(config, messageId);
+}
+
+/**
+ * Get unread important emails (for daily planner).
+ */
+export async function getUnreadImportant(config, maxResults = 30) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getUnreadImportant(config, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getUnreadImportant(config, maxResults);
+}
+
+/**
+ * Get today's emails.
+ */
+export async function getTodayEmails(config, maxResults = 50) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getTodayEmails(config, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getTodayEmails(config, maxResults);
+}
+
+/**
+ * Send an email.
+ */
+export async function sendEmail(config, to, subject, body, opts = {}) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.sendEmail(config, to, subject, body, opts);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.sendEmail(config, to, subject, body, opts);
+}
+
+/**
+ * Create a draft email.
+ */
+export async function createDraft(config, to, subject, body) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.createDraft(config, to, subject, body);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.createDraft(config, to, subject, body);
+}
+
+/**
+ * Get user's email profile.
+ */
+export async function getProfile(config) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getProfile(config);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getProfile(config);
+}
+
+// ── Calendar Functions ────────────────────────────────────────────────────
+
+/**
+ * Get today's events from all calendars.
+ */
+export async function getTodayEvents(config) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getTodayEvents(config);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getTodayEvents(config);
+}
+
+/**
+ * Get upcoming events (next N hours).
+ */
+export async function getUpcomingEvents(config, hours = 2) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getUpcomingEvents(config, hours);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getUpcomingEvents(config, hours);
+}
+
+/**
+ * Get events for a specific date.
+ */
+export async function getEventsForDate(config, date) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getEventsForDate(config, date);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getEventsForDate(config, date);
+}
+
+/**
+ * Create a new calendar event.
+ */
+export async function createEvent(config, event, calendarId = 'primary') {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.createEvent(config, event, calendarId);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.createEvent(config, event, calendarId);
+}
+
+/**
+ * Update an existing calendar event.
+ */
+export async function updateEvent(config, calendarId, eventId, patch) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.updateEvent(config, calendarId, eventId, patch);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.updateEvent(config, calendarId, eventId, patch);
+}
+
+/**
+ * List events for a date range.
+ */
+export async function listEvents(config, calendarId = 'primary', timeMin, timeMax) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.listEvents(config, calendarId, timeMin, timeMax);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.listEvents(config, calendarId, timeMin, timeMax);
+}