nothumanallowed 1.1.0 → 2.1.0

package/src/commands/google-auth.mjs

@@ -0,0 +1,29 @@
+/** nha google auth|status|revoke — Google account management */
+
+import { runAuthFlow, showStatus, revokeAuth } from '../services/google-oauth.mjs';
+import { loadConfig } from '../config.mjs';
+import { fail, info } from '../ui.mjs';
+
+export async function cmdGoogle(args) {
+  const sub = args[0] || 'auth';
+  const config = loadConfig();
+
+  switch (sub) {
+    case 'auth':
+    case 'login':
+    case 'connect':
+      return runAuthFlow(config);
+
+    case 'status':
+      return showStatus();
+
+    case 'revoke':
+    case 'disconnect':
+    case 'logout':
+      return revokeAuth();
+
+    default:
+      fail(`Unknown: nha google ${sub}`);
+      info('Commands: auth, status, revoke');
+  }
+}

package/src/commands/ops.mjs

@@ -0,0 +1,77 @@
+/** nha ops — Daemon control for Personal Agent Operations */
+
+import fs from 'fs';
+import path from 'path';
+import { startDaemon, stopDaemon, getDaemonStatus, isRunning } from '../services/ops-daemon.mjs';
+import { runPlanningPipeline } from '../services/ops-pipeline.mjs';
+import { loadConfig } from '../config.mjs';
+import { NHA_DIR } from '../constants.mjs';
+import { info, ok, fail, warn, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+
+export async function cmdOps(args) {
+  const sub = args[0] || 'status';
+
+  switch (sub) {
+    case 'start': {
+      const result = startDaemon();
+      if (result.ok) {
+        ok(`PAO daemon started (PID ${result.pid})`);
+        info('Monitoring Gmail + Calendar. Notifications enabled.');
+        info('Run "nha ops status" to check. "nha ops stop" to halt.');
+      } else {
+        warn(result.message);
+      }
+      return;
+    }
+
+    case 'stop': {
+      const result = stopDaemon();
+      if (result.ok) {
+        ok(`Daemon stopped (PID ${result.pid})`);
+      } else {
+        warn(result.message);
+      }
+      return;
+    }
+
+    case 'status': {
+      const status = getDaemonStatus();
+      console.log(`\n  ${BOLD}PAO Daemon Status${NC}\n`);
+      console.log(`  Running:          ${status.running ? G + 'yes' + NC + ` (PID ${status.pid})` : R + 'no' + NC}`);
+      if (status.startedAt) console.log(`  Started:          ${D}${status.startedAt}${NC}`);
+      if (status.lastMailCheck) console.log(`  Last mail check:  ${D}${status.lastMailCheck}${NC}`);
+      if (status.lastCalendarCheck) console.log(`  Last cal check:   ${D}${status.lastCalendarCheck}${NC}`);
+      if (status.lastPlanGenerated) console.log(`  Last plan:        ${D}${status.lastPlanGenerated}${NC}`);
+      if (status.errors > 0) console.log(`  Errors:           ${Y}${status.errors}${NC}`);
+      console.log('');
+      return;
+    }
+
+    case 'logs': {
+      const logFile = path.join(NHA_DIR, 'ops', 'daemon', 'daemon.log');
+      if (!fs.existsSync(logFile)) {
+        info('No daemon logs. Start with: nha ops start');
+        return;
+      }
+      const content = fs.readFileSync(logFile, 'utf-8');
+      const lines = content.split('\n').filter(Boolean);
+      const last50 = lines.slice(-50);
+      for (const line of last50) {
+        console.log(`  ${D}${line}${NC}`);
+      }
+      return;
+    }
+
+    case 'run': {
+      // One-shot: sync + plan + exit
+      const config = loadConfig();
+      info('Running one-shot PAO pipeline...');
+      await runPlanningPipeline(config, { refresh: true });
+      return;
+    }
+
+    default:
+      fail(`Unknown: nha ops ${sub}`);
+      info('Commands: start, stop, status, logs, run');
+  }
+}

package/src/commands/plan.mjs

@@ -0,0 +1,45 @@
+/** nha plan — Generate daily plan using 5 specialist agents */
+
+import { runPlanningPipeline } from '../services/ops-pipeline.mjs';
+import { loadConfig } from '../config.mjs';
+import { fail } from '../ui.mjs';
+
+export async function cmdPlan(args) {
+  const config = loadConfig();
+
+  if (!config.llm.apiKey) {
+    fail('No API key configured. Run: nha config set key YOUR_KEY');
+    process.exit(1);
+  }
+
+  let date = null;
+  let refresh = false;
+  let showOnly = false;
+
+  for (const arg of args) {
+    if (arg === '--refresh') { refresh = true; continue; }
+    if (arg === '--show') { showOnly = true; continue; }
+    if (arg === 'tomorrow') {
+      const d = new Date();
+      d.setDate(d.getDate() + 1);
+      date = d.toISOString().split('T')[0];
+      continue;
+    }
+    if (arg === 'yesterday') {
+      const d = new Date();
+      d.setDate(d.getDate() - 1);
+      date = d.toISOString().split('T')[0];
+      continue;
+    }
+    if (arg.startsWith('--date=')) {
+      date = arg.split('=')[1];
+      continue;
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(arg)) {
+      date = arg;
+      continue;
+    }
+  }
+
+  await runPlanningPipeline(config, { date, refresh, showOnly });
+}

package/src/commands/tasks.mjs

@@ -0,0 +1,132 @@
+/** nha tasks — Local task management */
+
+import { getTasks, addTask, completeTask, editTask, moveTask, getWeekTasks, getDayStats } from '../services/task-store.mjs';
+import { fail, info, ok, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+
+export async function cmdTasks(args) {
+  const sub = args[0];
+
+  // nha tasks (list today)
+  if (!sub || sub === 'list' || sub === 'today') {
+    const date = args[1] || undefined;
+    return showTasks(date);
+  }
+
+  // nha tasks add "description" [--priority high] [--due 14:00]
+  if (sub === 'add') {
+    const parts = args.slice(1);
+    let description = '';
+    let priority = 'medium';
+    let due = null;
+
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i] === '--priority' && parts[i + 1]) { priority = parts[++i]; continue; }
+      if (parts[i] === '--due' && parts[i + 1]) { due = parts[++i]; continue; }
+      if (parts[i] === '-p' && parts[i + 1]) { priority = parts[++i]; continue; }
+      description += (description ? ' ' : '') + parts[i];
+    }
+
+    if (!description) {
+      fail('Usage: nha tasks add "task description" [--priority high] [--due 14:00]');
+      return;
+    }
+
+    const task = addTask({ description, priority, due });
+    ok(`Task #${task.id} added: ${description}`);
+    return;
+  }
+
+  // nha tasks done <id>
+  if (sub === 'done' || sub === 'complete') {
+    const id = parseInt(args[1]);
+    if (!id) { fail('Usage: nha tasks done <task-id>'); return; }
+    if (completeTask(id)) {
+      ok(`Task #${id} completed`);
+    } else {
+      fail(`Task #${id} not found`);
+    }
+    return;
+  }
+
+  // nha tasks edit <id> "new description"
+  if (sub === 'edit') {
+    const id = parseInt(args[1]);
+    const desc = args.slice(2).join(' ');
+    if (!id || !desc) { fail('Usage: nha tasks edit <id> "new description"'); return; }
+    if (editTask(id, desc)) {
+      ok(`Task #${id} updated`);
+    } else {
+      fail(`Task #${id} not found`);
+    }
+    return;
+  }
+
+  // nha tasks move <id> tomorrow|YYYY-MM-DD
+  if (sub === 'move') {
+    const id = parseInt(args[1]);
+    let toDate = args[2];
+    if (!id || !toDate) { fail('Usage: nha tasks move <id> tomorrow'); return; }
+
+    if (toDate === 'tomorrow') {
+      const d = new Date();
+      d.setDate(d.getDate() + 1);
+      toDate = d.toISOString().split('T')[0];
+    }
+
+    const today = new Date().toISOString().split('T')[0];
+    if (moveTask(id, today, toDate)) {
+      ok(`Task #${id} moved to ${toDate}`);
+    } else {
+      fail(`Task #${id} not found`);
+    }
+    return;
+  }
+
+  // nha tasks week
+  if (sub === 'week') {
+    const week = getWeekTasks();
+    console.log(`\n  ${BOLD}Week Overview${NC}\n`);
+    for (const day of week) {
+      const stats = getDayStats(day.date);
+      const isToday = day.date === new Date().toISOString().split('T')[0];
+      const label = isToday ? `${BOLD}${day.day} ${day.date} (today)${NC}` : `${D}${day.day} ${day.date}${NC}`;
+      console.log(`  ${label}  ${stats.total > 0 ? `${G}${stats.done}${NC}/${stats.total} done` : D + 'empty' + NC}`);
+      for (const t of day.tasks.slice(0, 5)) {
+        const icon = t.status === 'done' ? `${G}✓${NC}` : t.priority === 'high' || t.priority === 'critical' ? `${Y}●${NC}` : `${D}○${NC}`;
+        console.log(`    ${icon} ${t.description}${t.due ? D + ' due ' + t.due + NC : ''}`);
+      }
+      if (day.tasks.length > 5) console.log(`    ${D}+${day.tasks.length - 5} more${NC}`);
+    }
+    console.log('');
+    return;
+  }
+
+  fail(`Unknown: nha tasks ${sub}`);
+  info('Commands: list, add, done, edit, move, week');
+}
+
+function showTasks(date) {
+  const tasks = getTasks(date);
+  const dateStr = date || new Date().toISOString().split('T')[0];
+  const stats = getDayStats(date);
+
+  console.log(`\n  ${BOLD}Tasks — ${dateStr}${NC}  ${D}(${stats.done}/${stats.total} done, ${stats.completionRate}%)${NC}\n`);
+
+  if (tasks.length === 0) {
+    info('No tasks for today. Add one: nha tasks add "your task"');
+    console.log('');
+    return;
+  }
+
+  for (const t of tasks) {
+    const statusIcon = t.status === 'done' ? `${G}✓${NC}` : `${D}○${NC}`;
+    const priorityBadge = t.priority === 'critical' ? `${R}[!!]${NC}` :
+      t.priority === 'high' ? `${Y}[!]${NC}` : '';
+    const dueStr = t.due ? ` ${D}due ${t.due}${NC}` : '';
+    const sourceStr = t.source !== 'manual' ? ` ${D}(${t.source})${NC}` : '';
+    const strikethrough = t.status === 'done' ? D : '';
+
+    console.log(`  ${statusIcon} ${strikethrough}#${t.id} ${t.description}${NC} ${priorityBadge}${dueStr}${sourceStr}`);
+  }
+  console.log('');
+}

package/src/config.mjs

@@ -48,6 +48,26 @@ const DEFAULT_CONFIG = {
     promptEvolutionEnabled: true,
     metaIntelligenceEnabled: true,
   },
+  google: {
+    clientId: '',
+    clientSecret: '',
+  },
+  ops: {
+    enabled: false,
+    planTime: '07:00',
+    summaryTime: '18:00',
+    pollIntervalMail: 300000,
+    pollIntervalCalendar: 900000,
+    meetingAlertMinutes: 30,
+    webhooks: {
+      telegram: '',
+      discord: '',
+    },
+    notifications: {
+      desktop: true,
+      terminal: true,
+    },
+  },
 };
 
 /**
@@ -152,6 +172,13 @@ export function setConfigValue(key, value) {
     'convergence': 'deliberation.convergence',
     'tribunal': 'deliberation.tribunalEnabled',
     'knowledge': 'features.knowledgeEnabled',
+    'google-client-id': 'google.clientId',
+    'google-client-secret': 'google.clientSecret',
+    'plan-time': 'ops.planTime',
+    'summary-time': 'ops.summaryTime',
+    'meeting-alert': 'ops.meetingAlertMinutes',
+    'telegram-webhook': 'ops.webhooks.telegram',
+    'discord-webhook': 'ops.webhooks.discord',
   };
 
   const resolved = aliases[key] || key;

package/src/constants.mjs

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
 
-export const VERSION = '1.1.0';
+export const VERSION = '2.1.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/google-calendar.mjs

@@ -0,0 +1,216 @@
+/**
+ * Google Calendar API wrapper — zero dependencies.
+ * All calls via native fetch to Calendar REST API.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getAccessToken } from './token-store.mjs';
+import { NHA_DIR } from '../constants.mjs';
+
+const CAL_BASE = 'https://www.googleapis.com/calendar/v3';
+const CAL_DIR = path.join(NHA_DIR, 'ops', 'calendar');
+
+/** Authenticated fetch */
+async function calFetch(config, urlPath, options = {}) {
+  const token = await getAccessToken(config);
+  const url = urlPath.startsWith('http') ? urlPath : `${CAL_BASE}${urlPath}`;
+
+  let res = await fetch(url, {
+    ...options,
+    headers: {
+      ...options.headers,
+      'Authorization': `Bearer ${token}`,
+    },
+  });
+
+  if (res.status === 401) {
+    const newToken = await getAccessToken(config);
+    res = await fetch(url, {
+      ...options,
+      headers: { ...options.headers, 'Authorization': `Bearer ${newToken}` },
+    });
+  }
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Calendar API ${res.status}: ${err}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * List all calendars the user has access to.
+ */
+export async function listCalendars(config) {
+  const data = await calFetch(config, '/users/me/calendarList');
+  return (data.items || []).map(c => ({
+    id: c.id,
+    summary: c.summary,
+    primary: c.primary || false,
+    timeZone: c.timeZone,
+    accessRole: c.accessRole,
+  }));
+}
+
+/**
+ * List events for a date range.
+ * @param {object} config
+ * @param {string} calendarId — 'primary' or specific ID
+ * @param {Date} timeMin
+ * @param {Date} timeMax
+ * @returns {Promise<Array>} parsed events
+ */
+export async function listEvents(config, calendarId = 'primary', timeMin, timeMax) {
+  const params = new URLSearchParams({
+    timeMin: timeMin.toISOString(),
+    timeMax: timeMax.toISOString(),
+    singleEvents: 'true',
+    orderBy: 'startTime',
+    maxResults: '50',
+  });
+
+  const data = await calFetch(config, `/calendars/${encodeURIComponent(calendarId)}/events?${params}`);
+  const events = (data.items || []).map(parseEvent);
+
+  // Cache events
+  cacheEvents(timeMin, events);
+  return events;
+}
+
+/**
+ * Get today's events from all calendars.
+ */
+export async function getTodayEvents(config) {
+  const now = new Date();
+  const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const endOfDay = new Date(startOfDay.getTime() + 86400000);
+
+  const calendars = await listCalendars(config);
+  const allEvents = [];
+
+  for (const cal of calendars) {
+    if (cal.accessRole === 'freeBusyReader') continue; // skip minimal access
+    try {
+      const events = await listEvents(config, cal.id, startOfDay, endOfDay);
+      for (const e of events) {
+        e.calendarName = cal.summary;
+        allEvents.push(e);
+      }
+    } catch { /* skip failed calendars */ }
+  }
+
+  // Sort by start time
+  allEvents.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  return allEvents;
+}
+
+/**
+ * Get events for a specific date.
+ */
+export async function getEventsForDate(config, date) {
+  const d = new Date(date);
+  const startOfDay = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  const endOfDay = new Date(startOfDay.getTime() + 86400000);
+  return listEvents(config, 'primary', startOfDay, endOfDay);
+}
+
+/**
+ * Get upcoming events (next N hours).
+ * @param {number} hours — look-ahead hours (default 2)
+ */
+export async function getUpcomingEvents(config, hours = 2) {
+  const now = new Date();
+  const end = new Date(now.getTime() + hours * 3600000);
+  return listEvents(config, 'primary', now, end);
+}
+
+/**
+ * Create a new event.
+ * @param {object} config
+ * @param {object} event — { summary, start, end, description, location, attendees }
+ * @param {string} calendarId
+ */
+export async function createEvent(config, event, calendarId = 'primary') {
+  const body = {
+    summary: event.summary,
+    description: event.description || '',
+    location: event.location || '',
+    start: {
+      dateTime: new Date(event.start).toISOString(),
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+    end: {
+      dateTime: new Date(event.end).toISOString(),
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+  };
+
+  if (event.attendees?.length) {
+    body.attendees = event.attendees.map(email => ({ email }));
+  }
+
+  return calFetch(config, `/calendars/${encodeURIComponent(calendarId)}/events`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Update an existing event (partial).
+ */
+export async function updateEvent(config, calendarId, eventId, patch) {
+  return calFetch(config, `/calendars/${encodeURIComponent(calendarId)}/events/${eventId}`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(patch),
+  });
+}
+
+// ── Event Parser ───────────────────────────────────────────────────────────
+
+function parseEvent(raw) {
+  const isAllDay = !!raw.start?.date;
+  return {
+    id: raw.id,
+    summary: raw.summary || '(no title)',
+    description: raw.description || '',
+    location: raw.location || '',
+    start: isAllDay ? raw.start.date : raw.start?.dateTime || '',
+    end: isAllDay ? raw.end.date : raw.end?.dateTime || '',
+    isAllDay,
+    status: raw.status || 'confirmed',
+    attendees: (raw.attendees || []).map(a => ({
+      email: a.email,
+      name: a.displayName || '',
+      responseStatus: a.responseStatus || 'needsAction',
+      self: a.self || false,
+    })),
+    organizer: raw.organizer?.email || '',
+    hangoutLink: raw.hangoutLink || '',
+    htmlLink: raw.htmlLink || '',
+    calendarName: '',
+  };
+}
+
+// ── Local Cache ────────────────────────────────────────────────────────────
+
+function cacheEvents(date, events) {
+  fs.mkdirSync(CAL_DIR, { recursive: true });
+  const dateStr = date instanceof Date ? date.toISOString().split('T')[0] : String(date);
+  const file = path.join(CAL_DIR, `events-${dateStr}.json`);
+  fs.writeFileSync(file, JSON.stringify(events, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Load cached events for a date.
+ */
+export function loadCachedEvents(date) {
+  const dateStr = date instanceof Date ? date.toISOString().split('T')[0] : String(date);
+  const file = path.join(CAL_DIR, `events-${dateStr}.json`);
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf-8')); }
+  catch { return null; }
+}