nothumanallowed 1.0.1 → 1.1.0

package/README.md

@@ -12,10 +12,11 @@ npm install -g nothumanallowed
 nha config set provider anthropic
 nha config set key sk-ant-api03-YOUR_KEY
 
-# Ask a single agent
-nha run "Audit this Express app for OWASP Top 10" --agents saber
+# Ask a single agent directly (no server, instant response)
+nha ask saber "Audit this Express app for OWASP Top 10"
+nha ask oracle "Analyze this dataset" --file data.csv
 
-# Or let multiple agents collaborate
+# Or let multiple agents collaborate via deliberation
 nha run "Design a Kubernetes deployment for a 10K RPS API"
 ```
 
@@ -105,7 +106,14 @@ nha install --all                # Install everything
 ## Commands
 
 ```bash
-# Run agents
+# Ask a single agent (direct call, no server)
+nha ask saber "prompt"        # Security audit
+nha ask oracle "prompt"       # Data analysis
+nha ask forge "prompt"        # DevOps & infrastructure
+nha ask saber "review this" --file app.js   # Attach a file
+nha ask saber "prompt" --provider openai    # Override provider
+
+# Multi-agent collaboration (server-routed deliberation)
 nha run "prompt"              # Auto-route to best agents
 nha run "prompt" --agents saber,zero   # Specific agents
 nha run --file prompt.txt     # From file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "NotHumanAllowed — 38 specialized AI agents for security, code, DevOps, data, and more. Use them individually or let them collaborate via multi-round deliberation.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -8,6 +8,7 @@ import { spawnCore } from './spawn.mjs';
 import { loadConfig, setConfigValue } from './config.mjs';
 import { checkForUpdates, runUpdate } from './updater.mjs';
 import { download } from './downloader.mjs';
+import { cmdAsk } from './commands/ask.mjs';
 import { banner, info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, M, B, R } from './ui.mjs';
 
 export async function main(argv) {
@@ -33,6 +34,9 @@ export async function main(argv) {
 
   // ── Command dispatch ─────────────────────────────────────────────────────
   switch (cmd) {
+    case 'ask':
+      return cmdAsk(args);
+
     case 'run':
       return cmdRun(args);
 
@@ -321,12 +325,13 @@ function cmdHelp() {
   console.log(`  ${BOLD}Usage:${NC}  nha <command> [options]\n`);
 
   console.log(`  ${C}Agents${NC}`);
+  console.log(`    ask <agent> "prompt"  Ask a single agent directly (no server)`);
+  console.log(`    ask saber "prompt" ${D}--file code.js${NC}   Attach a file`);
+  console.log(`    ask oracle "prompt" ${D}--provider openai${NC}`);
   console.log(`    agents                List all 38 specialized agents`);
   console.log(`    agents info <name>    Show agent capabilities & domain`);
-  console.log(`    agents tree           Show agent hierarchy by category`);
-  console.log(`    run "prompt"          Route to best agents automatically`);
-  console.log(`    run "prompt" ${D}--agents saber,zero${NC}   Use specific agents`);
-  console.log(`    run --file f.txt      Run from file\n`);
+  console.log(`    run "prompt"          Multi-agent collaboration (server-routed)`);
+  console.log(`    run "prompt" ${D}--agents saber,zero${NC}   Collaborate with specific agents\n`);
 
   console.log(`  ${C}Extensions${NC}  ${D}(downloadable agent modules)${NC}`);
   console.log(`    install <name>        Install an extension agent`);
@@ -349,7 +354,7 @@ function cmdHelp() {
   console.log(`  ${C}Quick Start${NC}`);
   console.log(`    ${D}1.${NC} nha config set provider anthropic`);
   console.log(`    ${D}2.${NC} nha config set key sk-ant-api03-YOUR_KEY`);
-  console.log(`    ${D}3.${NC} nha run "Audit this API for OWASP Top 10" --agents saber\n`);
+  console.log(`    ${D}3.${NC} nha ask saber "Audit this Express app for OWASP Top 10"\n`);
 
   console.log(`  ${D}38 agents: security, code, data, devops, creative, integration, and more.${NC}`);
   console.log(`  ${D}Use them solo or let them collaborate via multi-round deliberation.${NC}`);

package/src/commands/ask.mjs

@@ -0,0 +1,410 @@
+/**
+ * nha ask <agent> "prompt" — Direct single-agent call. No server. No session.
+ * Loads the agent's system prompt from ~/.nha/agents/<name>.mjs,
+ * calls the user's configured LLM provider, streams the response.
+ *
+ * Zero network calls except to the LLM provider.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config.mjs';
+import { AGENTS_DIR, AGENTS } from '../constants.mjs';
+import { fail, info, ok, C, G, Y, D, W, BOLD, NC, M } from '../ui.mjs';
+
+// ── LLM Providers ──────────────────────────────────────────────────────────
+
+async function callAnthropic(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callOpenAI(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callGemini(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callDeepSeek(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callGrok(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callMistral(apiKey, model, systemPrompt, userMessage, stream) {
+  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 || '';
+}
+
+async function callCohere(apiKey, model, systemPrompt, userMessage, stream) {
+  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 ──────────────────────────────────────────────────────
+
+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 {
+          // OpenAI-compatible (OpenAI, DeepSeek, Grok, Mistral)
+          chunk = json.choices?.[0]?.delta?.content || '';
+        }
+
+        if (chunk) {
+          process.stdout.write(chunk);
+          fullText += chunk;
+        }
+      } catch {}
+    }
+  }
+
+  process.stdout.write('\n');
+  return fullText;
+}
+
+// ── Provider Router ────────────────────────────────────────────────────────
+
+function getProviderCall(provider) {
+  const map = {
+    anthropic: callAnthropic,
+    openai: callOpenAI,
+    gemini: callGemini,
+    deepseek: callDeepSeek,
+    grok: callGrok,
+    mistral: callMistral,
+    cohere: callCohere,
+  };
+  return map[provider] || null;
+}
+
+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;
+}
+
+// ── Agent File Parser ──────────────────────────────────────────────────────
+
+function parseAgentFile(source, agentName) {
+  let card = { displayName: agentName.toUpperCase(), category: 'agent', tagline: '' };
+  let systemPrompt = '';
+
+  // Extract AGENT_CARD object
+  const cardMatch = source.match(/export\s+var\s+AGENT_CARD\s*=\s*(\{[\s\S]*?\});/);
+  if (cardMatch) {
+    try {
+      // Safe eval of the object literal (it only contains strings and arrays)
+      card = new Function('return ' + cardMatch[1])();
+    } catch {}
+  }
+
+  // Extract SYSTEM_PROMPT — concatenated string literals
+  const promptMatch = source.match(/export\s+var\s+SYSTEM_PROMPT\s*=\s*([\s\S]*?);(?:\n\nexport|\n\nvar|\n\n\/\/)/);
+  if (promptMatch) {
+    try {
+      // Evaluate the concatenated string expression
+      systemPrompt = new Function('return ' + promptMatch[1])();
+    } catch {}
+  }
+
+  // Fallback: try simpler pattern
+  if (!systemPrompt) {
+    const simpleMatch = source.match(/SYSTEM_PROMPT\s*=\s*'([\s\S]*?)';/);
+    if (simpleMatch) systemPrompt = simpleMatch[1];
+  }
+
+  return { card, systemPrompt };
+}
+
+// ── Main Command ───────────────────────────────────────────────────────────
+
+export async function cmdAsk(args) {
+  // Parse: nha ask <agent> "prompt" [--provider X] [--model Y] [--no-stream] [--file F]
+  const agentName = args[0];
+  if (!agentName || agentName.startsWith('-')) {
+    fail('Usage: nha ask <agent> "your question"');
+    fail('       nha ask saber "Audit this Express app for OWASP Top 10"');
+    fail('       nha ask oracle "Analyze this CSV for trends" --file data.csv');
+    console.log('');
+    info('Available agents: ' + AGENTS.join(', '));
+    process.exit(1);
+  }
+
+  // Find agent file
+  const agentFile = path.join(AGENTS_DIR, `${agentName}.mjs`);
+  if (!fs.existsSync(agentFile)) {
+    fail(`Agent "${agentName}" not found in ~/.nha/agents/`);
+    info('Available: ' + AGENTS.join(', '));
+    process.exit(1);
+  }
+
+  // Build prompt from remaining args
+  let promptParts = [];
+  let provider = null;
+  let model = null;
+  let stream = true;
+  let attachFile = null;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--provider' && args[i + 1]) { provider = args[++i]; continue; }
+    if (args[i] === '--model' && args[i + 1]) { model = args[++i]; continue; }
+    if (args[i] === '--no-stream') { stream = false; continue; }
+    if (args[i] === '--file' && args[i + 1]) { attachFile = args[++i]; continue; }
+    promptParts.push(args[i]);
+  }
+
+  let userMessage = promptParts.join(' ');
+  if (!userMessage) {
+    fail('No prompt provided.');
+    fail('Usage: nha ask saber "your question here"');
+    process.exit(1);
+  }
+
+  // Attach file content if provided
+  if (attachFile) {
+    const filePath = path.resolve(attachFile);
+    if (!fs.existsSync(filePath)) {
+      fail(`File not found: ${attachFile}`);
+      process.exit(1);
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const maxChars = 100_000;
+    const truncated = content.length > maxChars ? content.slice(0, maxChars) + '\n\n[... truncated ...]' : content;
+    userMessage += `\n\n--- Attached file: ${path.basename(filePath)} ---\n${truncated}`;
+  }
+
+  // Load config
+  const config = loadConfig();
+  provider = provider || config.llm.provider || 'anthropic';
+  model = model || config.llm.model || null;
+  const apiKey = getApiKey(config, provider);
+
+  if (!apiKey) {
+    fail(`No API key for ${provider}. Run: nha config set key YOUR_KEY`);
+    process.exit(1);
+  }
+
+  // Load agent — parse AGENT_CARD and SYSTEM_PROMPT from file text
+  // (can't use dynamic import because agent files have syntax incompatible with standalone ESM import)
+  const agentSource = fs.readFileSync(agentFile, 'utf-8');
+  const { card, systemPrompt } = parseAgentFile(agentSource, agentName);
+
+  if (!systemPrompt) {
+    fail(`Agent "${agentName}" has no SYSTEM_PROMPT in its file.`);
+    process.exit(1);
+  }
+
+  // Print header
+  console.log(`\n  ${BOLD}${card?.displayName || agentName.toUpperCase()}${NC} ${D}(${card?.tagline || card?.category || 'agent'})${NC}`);
+  console.log(`  ${D}Provider: ${provider}${model ? ' / ' + model : ''} | Direct call — no server${NC}\n`);
+
+  // Call LLM
+  const callFn = getProviderCall(provider);
+  if (!callFn) {
+    fail(`Unknown provider: ${provider}`);
+    info('Supported: anthropic, openai, gemini, deepseek, grok, mistral, cohere');
+    process.exit(1);
+  }
+
+  const startTime = Date.now();
+
+  try {
+    // Gemini and Cohere don't support streaming well via their native APIs
+    const useStream = stream && (provider === 'anthropic' || provider === 'openai' || provider === 'deepseek' || provider === 'grok' || provider === 'mistral');
+
+    const result = await callFn(apiKey, model, systemPrompt, userMessage, useStream);
+
+    if (!useStream && result) {
+      console.log(result);
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`\n  ${D}${elapsed}s | ${provider}${model ? ' / ' + model : ''} | ${card?.displayName || agentName}${NC}\n`);
+  } catch (err) {
+    fail(err.message);
+    process.exit(1);
+  }
+}

package/src/constants.mjs

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