nothumanallowed 4.1.0 → 6.0.0

package/src/commands/chat.mjs

@@ -11,25 +11,22 @@
 import readline from 'readline';
 import { loadConfig } from '../config.mjs';
 import { callLLM } from '../services/llm.mjs';
+import { loadChatHistory, saveChatHistory, extractMemory } from '../services/memory.mjs';
 import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, M, R, B } from '../ui.mjs';
 
-// ── Gmail imports ────────────────────────────────────────────────────────────
+// ── Mail + Calendar imports (unified router — Google or Microsoft) ───────────
 import {
   listMessages,
   getMessage,
   getUnreadImportant,
   sendEmail,
   createDraft,
-} from '../services/google-gmail.mjs';
-
-// ── Calendar imports ─────────────────────────────────────────────────────────
-import {
   getTodayEvents,
   getUpcomingEvents,
   getEventsForDate,
   createEvent,
   updateEvent,
-} from '../services/google-calendar.mjs';
+} from '../services/mail-router.mjs';
 
 // ── Task imports ─────────────────────────────────────────────────────────────
 import {
@@ -497,8 +494,9 @@ async function handleSlashCommand(input, config, history) {
 
   if (trimmed === '/clear') {
     history.length = 0;
+    try { saveChatHistory([]); } catch { /* non-critical */ }
     console.clear();
-    console.log(`  ${G}Conversation cleared.${NC}`);
+    console.log(`  ${G}Conversation cleared (memory preserved, chat history reset).${NC}`);
     return true;
   }
 
@@ -586,7 +584,11 @@ export async function cmdChat(args) {
     terminal: true,
   });
 
-  const history = [];
+  // Load persisted chat history from previous sessions
+  const history = loadChatHistory();
+  if (history.length > 0) {
+    ok(`Loaded ${Math.floor(history.length / 2)} previous conversation turns from memory.`);
+  }
   const systemPrompt = buildSystemPrompt(initialContext);
 
   // ── Graceful exit ───────────────────────────────────────────────────────
@@ -699,6 +701,10 @@ export async function cmdChat(args) {
         history.shift();
         history.shift();
       }
+
+      // Persist chat history and extract episodic memory
+      try { saveChatHistory(history); } catch { /* non-critical */ }
+      try { extractMemory('chat', input, response); } catch { /* non-critical */ }
     } catch (err) {
       process.stdout.write('\r' + ' '.repeat(40) + '\r');
       console.log(`\n  ${R}LLM error: ${err.message}${NC}\n`);

package/src/commands/microsoft-auth.mjs

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

package/src/commands/ops.mjs

@@ -17,6 +17,20 @@ export async function cmdOps(args) {
       if (result.ok) {
         ok(`PAO daemon started (PID ${result.pid})`);
         info('Monitoring Gmail + Calendar. Notifications enabled.');
+
+        const config = loadConfig();
+        const hasTelegram = !!config.responder?.telegram?.token;
+        const hasDiscord = !!config.responder?.discord?.token;
+        if (hasTelegram || hasDiscord) {
+          const platforms = [hasTelegram && 'Telegram', hasDiscord && 'Discord'].filter(Boolean).join(' + ');
+          info(`Message responder active: ${platforms}`);
+        }
+
+        const proactive = config.ops?.proactive?.enabled !== false;
+        if (proactive) {
+          info('Proactive intelligence enabled (follow-ups, meeting prep, deadlines).');
+        }
+
         info('Run "nha ops status" to check. "nha ops stop" to halt.');
       } else {
         warn(result.message);
@@ -36,6 +50,8 @@ export async function cmdOps(args) {
 
     case 'status': {
       const status = getDaemonStatus();
+      const config = loadConfig();
+
       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}`);
@@ -43,6 +59,27 @@ export async function cmdOps(args) {
       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}`);
+
+      // Proactive Intelligence Engine status
+      const proactive = status.proactive || {};
+      console.log(`\n  ${BOLD}Proactive Intelligence${NC}\n`);
+      console.log(`  Enabled:          ${proactive.enabled !== false ? G + 'yes' + NC : D + 'no' + NC}`);
+      console.log(`  Email follow-up:  ${proactive.emailFollowUp !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Meeting prep:     ${proactive.meetingPrep !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Pattern detect:   ${proactive.patterns !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Deadline alerts:  ${proactive.deadlines !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      if (status.lastProactiveCheck) console.log(`  Last check:       ${D}${status.lastProactiveCheck}${NC}`);
+      if (status.lastPatternDetection) console.log(`  Last patterns:    ${D}${status.lastPatternDetection}${NC}`);
+
+      // Message Responder status
+      const responder = status.responder || {};
+      const telegramConfigured = !!config.responder?.telegram?.token;
+      const discordConfigured = !!config.responder?.discord?.token;
+      console.log(`\n  ${BOLD}Message Responder${NC}\n`);
+      console.log(`  Telegram:         ${responder.telegram ? G + 'active' + NC : telegramConfigured ? Y + 'configured (daemon restart needed)' + NC : D + 'not configured' + NC}`);
+      console.log(`  Discord:          ${responder.discord ? G + 'active' + NC : discordConfigured ? Y + 'configured (daemon restart needed)' + NC : D + 'not configured' + NC}`);
+      console.log(`  Auto-route:       ${config.responder?.autoRoute !== false ? G + 'keyword routing' + NC : D + 'CONDUCTOR only' + NC}`);
+
       console.log('');
       return;
     }

package/src/commands/plugin.mjs

@@ -0,0 +1,481 @@
+/**
+ * nha plugin — Plugin system for user-extensible commands.
+ *
+ * Plugins are .mjs files stored in ~/.nha/plugins/. Each exports a
+ * PLUGIN_CARD object and a run() function. The plugin system gives plugins
+ * access to NHA services (LLM, Gmail, Calendar, Tasks, notifications)
+ * through a context object.
+ *
+ * Subcommands:
+ *   nha plugin list               — List installed + available plugins
+ *   nha plugin install <name>     — Download plugin from NHA server
+ *   nha plugin run <name> [args]  — Execute a plugin
+ *   nha plugin create <name>      — Scaffold a new plugin from template
+ *   nha plugin remove <name>      — Remove an installed plugin
+ *   nha plugin info <name>        — Show plugin details
+ *
+ * Zero npm dependencies — Node.js 22 native only.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config.mjs';
+import { callLLM, callAgent } from '../services/llm.mjs';
+import { NHA_DIR, PLUGINS_DIR, BASE_URL, VERSION } from '../constants.mjs';
+import { download } from '../downloader.mjs';
+import { info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const PLUGINS_REGISTRY_URL = `${BASE_URL}/plugins/registry.json`;
+
+// ── Plugin Loader ──────────────────────────────────────────────────────────
+
+/**
+ * Load a plugin by name from the plugins directory.
+ * Returns { card, run } or null if not found.
+ */
+export async function loadPlugin(name) {
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '');
+  const pluginFile = path.join(PLUGINS_DIR, `${sanitized}.mjs`);
+
+  if (!fs.existsSync(pluginFile)) return null;
+
+  try {
+    const mod = await import(`file://${pluginFile}`);
+    return {
+      card: mod.PLUGIN_CARD || { name: sanitized, version: '0.0.0', description: '', commands: [] },
+      run: typeof mod.run === 'function' ? mod.run : null,
+      filePath: pluginFile,
+    };
+  } catch (err) {
+    fail(`Failed to load plugin "${sanitized}": ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Load all installed plugins. Returns an array of { card, run, filePath }.
+ */
+export async function loadAllPlugins() {
+  if (!fs.existsSync(PLUGINS_DIR)) return [];
+
+  const files = fs.readdirSync(PLUGINS_DIR).filter(f => f.endsWith('.mjs'));
+  const plugins = [];
+
+  for (const file of files) {
+    const name = file.replace(/\.mjs$/, '');
+    const plugin = await loadPlugin(name);
+    if (plugin) plugins.push(plugin);
+  }
+
+  return plugins;
+}
+
+/**
+ * Check if any installed plugin handles the given command name.
+ * Returns { plugin, command } or null.
+ */
+export async function findPluginForCommand(commandName) {
+  const plugins = await loadAllPlugins();
+
+  for (const plugin of plugins) {
+    const commands = plugin.card.commands || [];
+    if (commands.includes(commandName) || plugin.card.name === commandName) {
+      return { plugin, command: commandName };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Build the context object passed to plugin run() functions.
+ * Gives plugins access to all NHA services.
+ */
+async function buildPluginContext(config) {
+  const gmail = await import('../services/google-gmail.mjs').catch(() => null);
+  const calendar = await import('../services/google-calendar.mjs').catch(() => null);
+  const taskStore = await import('../services/task-store.mjs').catch(() => null);
+  const notifier = await import('../services/notification.mjs').catch(() => null);
+
+  return {
+    config,
+    version: VERSION,
+    pluginsDir: PLUGINS_DIR,
+    nhaDir: NHA_DIR,
+
+    // LLM
+    callLLM: (systemPrompt, userMessage, opts) => callLLM(config, systemPrompt, userMessage, opts),
+    callAgent: (agentName, userMessage, opts) => callAgent(config, agentName, userMessage, opts),
+
+    // Gmail
+    gmail: gmail ? {
+      listMessages: (query, max) => gmail.listMessages(config, query, max),
+      getMessage: (id) => gmail.getMessage(config, id),
+      getUnreadImportant: (max) => gmail.getUnreadImportant(config, max),
+      sendEmail: (to, subject, body, opts) => gmail.sendEmail(config, to, subject, body, opts),
+      createDraft: (to, subject, body) => gmail.createDraft(config, to, subject, body),
+    } : null,
+
+    // Calendar
+    calendar: calendar ? {
+      getTodayEvents: () => calendar.getTodayEvents(config),
+      getUpcomingEvents: (hours) => calendar.getUpcomingEvents(config, hours),
+      getEventsForDate: (date) => calendar.getEventsForDate(config, date),
+      createEvent: (data) => calendar.createEvent(config, data),
+      updateEvent: (calId, eventId, data) => calendar.updateEvent(config, calId, eventId, data),
+    } : null,
+
+    // Tasks
+    tasks: taskStore ? {
+      getTasks: () => taskStore.getTasks(),
+      addTask: (data) => taskStore.addTask(data),
+      completeTask: (id) => taskStore.completeTask(id),
+      moveTask: (id, from, to) => taskStore.moveTask(id, from, to),
+      getDayStats: () => taskStore.getDayStats(),
+    } : null,
+
+    // Notifications
+    notify: notifier ? (title, message) => notifier.notify(title, message, config) : null,
+
+    // Filesystem helpers (sandboxed to plugins dir)
+    fs: {
+      readFile: (name) => fs.readFileSync(path.join(PLUGINS_DIR, name), 'utf-8'),
+      writeFile: (name, content) => fs.writeFileSync(path.join(PLUGINS_DIR, name), content, 'utf-8'),
+      exists: (name) => fs.existsSync(path.join(PLUGINS_DIR, name)),
+    },
+
+    // Fetch (for plugins that need HTTP)
+    fetch: globalThis.fetch,
+  };
+}
+
+// ── Registry (available plugins from server) ────────────────────────────────
+
+async function fetchRegistry() {
+  try {
+    const res = await fetch(PLUGINS_REGISTRY_URL, { signal: AbortSignal.timeout(10000) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return Array.isArray(data.plugins) ? data.plugins : [];
+  } catch {
+    return [];
+  }
+}
+
+// ── Plugin Template ─────────────────────────────────────────────────────────
+
+function generateTemplate(name) {
+  const camelName = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+
+  return `/**
+ * NHA Plugin: ${name}
+ *
+ * This plugin was scaffolded by "nha plugin create ${name}".
+ * Edit the PLUGIN_CARD and run() function to add your functionality.
+ *
+ * Usage:
+ *   nha plugin run ${name}
+ *   nha plugin run ${name} --help
+ */
+
+export const PLUGIN_CARD = {
+  name: '${name}',
+  version: '1.0.0',
+  description: 'Describe what this plugin does',
+  author: '',
+  commands: ['${name}'],
+};
+
+/**
+ * Main entry point for the plugin.
+ *
+ * @param {string[]} args - Command-line arguments passed after the plugin name
+ * @param {object} context - NHA services context
+ * @param {function} context.callLLM - Call any LLM provider: callLLM(systemPrompt, userMessage, opts?)
+ * @param {function} context.callAgent - Call a named agent: callAgent('saber', 'Audit this code')
+ * @param {object|null} context.gmail - Gmail service (listMessages, getMessage, sendEmail, createDraft)
+ * @param {object|null} context.calendar - Calendar service (getTodayEvents, getUpcomingEvents, createEvent)
+ * @param {object|null} context.tasks - Tasks service (getTasks, addTask, completeTask, moveTask)
+ * @param {function|null} context.notify - Send a desktop notification: notify(title, message)
+ * @param {object} context.config - NHA config object
+ * @param {function} context.fetch - Global fetch for HTTP requests
+ * @param {object} context.fs - Sandboxed fs: readFile(name), writeFile(name, content), exists(name)
+ * @returns {Promise<string>} Result to display to the user
+ */
+export async function run(args, context) {
+  if (args.includes('--help')) {
+    return [
+      'Usage: nha plugin run ${name} [options]',
+      '',
+      'Options:',
+      '  --help    Show this help message',
+      '',
+      'Description:',
+      '  ' + PLUGIN_CARD.description,
+    ].join('\\n');
+  }
+
+  // Example: call an agent
+  // const analysis = await context.callAgent('saber', 'Analyze this for security issues');
+
+  // Example: call LLM directly
+  // const response = await context.callLLM('You are a helpful assistant.', 'Hello!');
+
+  // Example: list tasks
+  // if (context.tasks) {
+  //   const tasks = context.tasks.getTasks();
+  //   return 'Your tasks: ' + tasks.map(t => t.description).join(', ');
+  // }
+
+  return 'Plugin ${name} executed successfully. Edit ~/.nha/plugins/${name}.mjs to add your logic.';
+}
+`;
+}
+
+// ── Subcommand Handlers ─────────────────────────────────────────────────────
+
+async function cmdList() {
+  console.log(`\n  ${BOLD}NHA Plugins${NC}\n`);
+
+  // Installed plugins
+  const installed = await loadAllPlugins();
+
+  if (installed.length > 0) {
+    console.log(`  ${C}Installed${NC}  ${D}(~/.nha/plugins/)${NC}\n`);
+    for (const p of installed) {
+      const card = p.card;
+      console.log(`  ${G}*${NC} ${W}${card.name}${NC} ${D}v${card.version}${NC}`);
+      if (card.description) console.log(`    ${D}${card.description}${NC}`);
+      if (card.commands && card.commands.length > 0) {
+        console.log(`    ${D}Commands: ${card.commands.join(', ')}${NC}`);
+      }
+    }
+  } else {
+    console.log(`  ${D}No plugins installed.${NC}`);
+  }
+
+  // Available from server
+  console.log('');
+  info('Checking server for available plugins...');
+  const registry = await fetchRegistry();
+
+  if (registry.length > 0) {
+    console.log(`\n  ${C}Available from Server${NC}\n`);
+    const installedNames = new Set(installed.map(p => p.card.name));
+    for (const p of registry) {
+      const status = installedNames.has(p.name) ? `${G}installed${NC}` : `${D}available${NC}`;
+      console.log(`  ${D}*${NC} ${W}${p.name}${NC} ${D}v${p.version}${NC} — ${status}`);
+      if (p.description) console.log(`    ${D}${p.description}${NC}`);
+    }
+  } else {
+    console.log(`\n  ${D}No plugins available from server (or server unreachable).${NC}`);
+    console.log(`  ${D}Create your own: nha plugin create my-plugin${NC}`);
+  }
+
+  console.log('');
+}
+
+async function cmdInstall(name) {
+  if (!name) {
+    fail('Usage: nha plugin install <name>');
+    return;
+  }
+
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '').replace(/\.mjs$/, '');
+  fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+
+  const dest = path.join(PLUGINS_DIR, `${sanitized}.mjs`);
+  const url = `${BASE_URL}/plugins/${sanitized}.mjs`;
+
+  info(`Installing plugin "${sanitized}" from ${url}...`);
+
+  const success = await download(url, dest, { timeout: 15000 });
+  if (success) {
+    // Validate the downloaded plugin
+    const plugin = await loadPlugin(sanitized);
+    if (plugin && plugin.run) {
+      ok(`Plugin "${sanitized}" installed to ~/.nha/plugins/`);
+      if (plugin.card.description) {
+        info(plugin.card.description);
+      }
+      if (plugin.card.commands && plugin.card.commands.length > 0) {
+        info(`Commands: ${plugin.card.commands.join(', ')}`);
+      }
+    } else if (plugin) {
+      warn(`Plugin "${sanitized}" installed but has no run() function.`);
+    } else {
+      warn(`Plugin "${sanitized}" downloaded but could not be loaded. Check the file.`);
+    }
+  } else {
+    fail(`Could not download plugin "${sanitized}".`);
+    info(`Try: nha plugin create ${sanitized}  (to create it locally)`);
+  }
+}
+
+async function cmdRun(name, args) {
+  if (!name) {
+    fail('Usage: nha plugin run <name> [args...]');
+    return;
+  }
+
+  const plugin = await loadPlugin(name);
+  if (!plugin) {
+    fail(`Plugin "${name}" not found. Install it first: nha plugin install ${name}`);
+    return;
+  }
+
+  if (!plugin.run) {
+    fail(`Plugin "${name}" has no run() function.`);
+    return;
+  }
+
+  const config = loadConfig();
+  const context = await buildPluginContext(config);
+
+  info(`Running plugin "${name}" v${plugin.card.version}...`);
+  console.log('');
+
+  try {
+    const result = await plugin.run(args, context);
+    if (result) {
+      console.log(result);
+    }
+    console.log('');
+    ok(`Plugin "${name}" completed.`);
+  } catch (err) {
+    fail(`Plugin "${name}" error: ${err.message}`);
+    if (err.stack) {
+      console.log(`  ${D}${err.stack.split('\n').slice(1, 4).join('\n  ')}${NC}`);
+    }
+  }
+}
+
+async function cmdCreate(name) {
+  if (!name) {
+    fail('Usage: nha plugin create <name>');
+    return;
+  }
+
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '');
+  if (!sanitized) {
+    fail('Invalid plugin name. Use only letters, numbers, hyphens, underscores.');
+    return;
+  }
+
+  fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+
+  const dest = path.join(PLUGINS_DIR, `${sanitized}.mjs`);
+  if (fs.existsSync(dest)) {
+    fail(`Plugin "${sanitized}" already exists at ${dest}`);
+    info('Edit it directly or remove it first: nha plugin remove ' + sanitized);
+    return;
+  }
+
+  const template = generateTemplate(sanitized);
+  fs.writeFileSync(dest, template, 'utf-8');
+
+  ok(`Plugin "${sanitized}" created at ~/.nha/plugins/${sanitized}.mjs`);
+  console.log('');
+  info('Edit the file to add your logic:');
+  console.log(`  ${D}${dest}${NC}`);
+  console.log('');
+  info('Then run it:');
+  console.log(`  ${D}nha plugin run ${sanitized}${NC}`);
+  console.log('');
+}
+
+async function cmdRemove(name) {
+  if (!name) {
+    fail('Usage: nha plugin remove <name>');
+    return;
+  }
+
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '').replace(/\.mjs$/, '');
+  const dest = path.join(PLUGINS_DIR, `${sanitized}.mjs`);
+
+  if (!fs.existsSync(dest)) {
+    fail(`Plugin "${sanitized}" not found.`);
+    return;
+  }
+
+  fs.rmSync(dest, { force: true });
+  ok(`Plugin "${sanitized}" removed.`);
+}
+
+async function cmdInfo(name) {
+  if (!name) {
+    fail('Usage: nha plugin info <name>');
+    return;
+  }
+
+  const plugin = await loadPlugin(name);
+  if (!plugin) {
+    fail(`Plugin "${name}" not found.`);
+    return;
+  }
+
+  const card = plugin.card;
+  console.log(`\n  ${BOLD}${W}${card.name}${NC}  ${D}v${card.version}${NC}\n`);
+  if (card.description) console.log(`  ${card.description}\n`);
+  if (card.author) console.log(`  ${D}Author:${NC}   ${card.author}`);
+  if (card.commands && card.commands.length > 0) console.log(`  ${D}Commands:${NC} ${card.commands.join(', ')}`);
+  console.log(`  ${D}File:${NC}     ${plugin.filePath}`);
+  console.log(`  ${D}Has run():${NC} ${plugin.run ? G + 'yes' : R + 'no'}${NC}`);
+  console.log('');
+}
+
+// ── Main Command Router ─────────────────────────────────────────────────────
+
+export async function cmdPlugin(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case 'list':
+    case 'ls':
+    case undefined:
+      return cmdList();
+
+    case 'install':
+    case 'add':
+      return cmdInstall(rest[0]);
+
+    case 'run':
+    case 'exec':
+      return cmdRun(rest[0], rest.slice(1));
+
+    case 'create':
+    case 'new':
+    case 'init':
+      return cmdCreate(rest[0]);
+
+    case 'remove':
+    case 'rm':
+    case 'uninstall':
+      return cmdRemove(rest[0]);
+
+    case 'info':
+    case 'show':
+      return cmdInfo(rest[0]);
+
+    default:
+      // If the subcommand matches a plugin name, run it directly
+      const plugin = await loadPlugin(sub);
+      if (plugin && plugin.run) {
+        return cmdRun(sub, rest);
+      }
+
+      fail(`Unknown plugin subcommand: ${sub}`);
+      console.log('');
+      info('Usage:');
+      console.log(`  ${D}nha plugin list${NC}              List installed & available plugins`);
+      console.log(`  ${D}nha plugin install <name>${NC}    Download a plugin from NHA server`);
+      console.log(`  ${D}nha plugin run <name> [args]${NC} Execute a plugin`);
+      console.log(`  ${D}nha plugin create <name>${NC}     Scaffold a new plugin`);
+      console.log(`  ${D}nha plugin remove <name>${NC}     Remove an installed plugin`);
+      console.log(`  ${D}nha plugin info <name>${NC}       Show plugin details`);
+      console.log('');
+  }
+}