neohive 6.0.3 → 6.1.0

package/cli.js

@@ -4,12 +4,24 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { upsertNeohiveMcpInToml } = require('./lib/codex-neohive-toml');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CLI_CONFIG — centralized constants for the Neohive CLI
+// ─────────────────────────────────────────────────────────────────────────────
+const CLI_CONFIG = {
+  MCP_TOOL_TIMEOUT_S:   300,    // MCP tool timeout written to IDE config files (seconds)
+  OLLAMA_DETECT_TIMEOUT_MS: 5000, // timeout for 'ollama --version' probe
+  OLLAMA_HEARTBEAT_MS:  10000,  // how often Ollama agent writes heartbeat
+  OLLAMA_POLL_MS:        2000,  // how often Ollama agent polls for messages
+  MSG_MAX_CHARS:        10000,  // max length of --msg text argument
+};
 
 const command = process.argv[2];
 
 function printUsage() {
   console.log(`
-  Neohive v6.0.0
+  Neohive v6.1.0
   The MCP collaboration layer for AI CLI tools.
 
   Usage:
@@ -18,7 +30,10 @@ function printUsage() {
     npx neohive init --gemini       Configure for Gemini CLI only
     npx neohive init --codex        Configure for Codex CLI only
     npx neohive init --cursor       Configure for Cursor IDE only (.cursor/mcp.json)
+    npx neohive init --vscode       Configure for VS Code GitHub Copilot
+    npx neohive init --antigravity  Configure for Antigravity IDE
     npx neohive init --all          Configure for all supported CLIs
+    npx neohive mcp                 Start MCP stdio server (used internally by IDE configs)
     npx neohive init --ollama       Setup Ollama local LLM bridge
     npx neohive init --template T   Initialize with a team template
     npx neohive serve               Run MCP server in HTTP mode (port 4321)
@@ -69,7 +84,7 @@ function detectCLIs() {
 // Detect Ollama installation
 function detectOllama() {
   try {
-    const version = execSync('ollama --version', { encoding: 'utf8', timeout: 5000 }).trim();
+    const version = execSync('ollama --version', { encoding: 'utf8', timeout: CLI_CONFIG.OLLAMA_DETECT_TIMEOUT_MS }).trim();
     return { installed: true, version };
   } catch {
     return { installed: false };
@@ -81,6 +96,16 @@ function dataDir(cwd) {
   return path.join(cwd, '.neohive');
 }
 
+// Absolute Node binary for MCP configs — CLIs often spawn without Volta/nvm PATH, so plain "node" fails.
+function mcpNodeCommand() {
+  return process.execPath;
+}
+
+// MCP stdio "command" for npx — do not use /usr/bin/env (not portable on Windows).
+function mcpNpxCommand() {
+  return process.platform === 'win32' ? 'npx.cmd' : 'npx';
+}
+
 // Configure for Claude Code (.mcp.json in project root)
 function setupClaude(serverPath, cwd) {
   const mcpConfigPath = path.join(cwd, '.mcp.json');
@@ -98,9 +123,9 @@ function setupClaude(serverPath, cwd) {
   }
 
   mcpConfig.mcpServers['neohive'] = {
-    command: 'node',
+    command: mcpNodeCommand(),
     args: [serverPath],
-    timeout: 300,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
   };
 
   fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + '\n');
@@ -130,14 +155,199 @@ function setupGemini(serverPath, cwd) {
   }
 
   settings.mcpServers['neohive'] = {
-    command: 'node',
+    command: mcpNodeCommand(),
     args: [serverPath],
-    timeout: 300,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
     trust: true,
   };
 
+  if (!settings.context) settings.context = {};
+  if (!settings.context.files) settings.context.files = [];
+  if (!settings.context.files.includes('GEMINI.md')) {
+    settings.context.files.push('GEMINI.md');
+  }
+
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
   console.log('  [ok] Gemini CLI: .gemini/settings.json updated');
+
+  // Write GEMINI.md agent rules if not already present
+  const geminiMdPath = path.join(cwd, 'GEMINI.md');
+  if (!fs.existsSync(geminiMdPath)) {
+    fs.writeFileSync(geminiMdPath, geminiMdTemplate());
+    console.log('  [ok] Gemini CLI: GEMINI.md created with agent rules');
+  } else {
+    console.log('  [skip] GEMINI.md already exists — not overwriting');
+  }
+}
+
+function geminiMdTemplate() {
+  return `# Neohive Agent — Gemini CLI
+
+You are a Neohive team agent. Follow these rules exactly, every session, no exceptions.
+
+## First thing to do — always
+
+1. Call \`register\` with your assigned name (e.g. \`register(name="Gemini")\`)
+2. Call \`get_briefing\` to load project context and current work
+3. Call \`listen\` to wait for messages from the Coordinator
+
+Do NOT explore the codebase, ask questions, or take initiative before completing these 3 steps.
+
+## Core rules
+
+- **After every action** — call \`listen()\`. This is how you receive your next task.
+- **Before starting a task** — call \`update_task(id, status="in_progress")\`
+- **After finishing a task** — call \`update_task(id, status="done")\`, then report to Coordinator
+- **Before editing a file** — call \`lock_file(path)\`. Call \`unlock_file(path)\` when done.
+- **Check tasks first** — call \`list_tasks()\` before starting anything new. Never work on another agent's task.
+- **Keep messages short** — 2–3 paragraphs max. Lead with what changed, then files, then decisions.
+
+## Workflow
+
+\`\`\`
+register → get_briefing → listen → [receive task] → update_task(in_progress)
+→ do work → update_task(done) → send_message(Coordinator, summary) → listen
+\`\`\`
+
+Repeat the last 5 steps for every task. Never exit the listen loop.
+
+## Available MCP tools
+
+**Messaging:** \`register\`, \`send_message\`, \`broadcast\`, \`listen\`, \`check_messages\`, \`get_history\`, \`handoff\`
+**Tasks:** \`create_task\`, \`update_task\`, \`list_tasks\`
+**Workflows:** \`create_workflow\`, \`advance_workflow\`, \`workflow_status\`
+**Workspaces:** \`workspace_write\`, \`workspace_read\`, \`workspace_list\`
+**Branching:** \`fork_conversation\`, \`switch_branch\`, \`list_branches\`
+
+## What NOT to do
+
+- Do not self-assign tasks
+- Do not modify files without a task assigned to you
+- Do not skip \`listen()\` after responding
+- Do not send long messages — be concise
+- Do not ask the Coordinator for permission before starting an assigned task — just do it
+`;
+}
+
+// Configure for VS Code GitHub Copilot (.vscode/mcp.json + copilot instructions)
+function setupVSCode(cwd) {
+  const vscodeDir = path.join(cwd, '.vscode');
+  const mcpPath = path.join(vscodeDir, 'mcp.json');
+  if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+
+  let config = { servers: {} };
+  if (fs.existsSync(mcpPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+      if (!config.servers) config.servers = {};
+    } catch {
+      fs.copyFileSync(mcpPath, mcpPath + '.backup');
+      console.log('  [warn] Existing .vscode/mcp.json was invalid — backed up');
+    }
+  }
+
+  config.servers['neohive'] = {
+    type: 'stdio',
+    command: mcpNpxCommand(),
+    args: ['-y', 'neohive', 'mcp'],
+    env: {
+      NEOHIVE_DATA_DIR: '${workspaceFolder}/.neohive',
+    },
+    cwd: '${workspaceFolder}',
+  };
+
+  fs.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+  console.log('  [ok] VS Code: .vscode/mcp.json updated');
+
+  // Write copilot instructions
+  const githubDir = path.join(cwd, '.github');
+  const instructionsPath = path.join(githubDir, 'copilot-instructions.md');
+  if (!fs.existsSync(githubDir)) fs.mkdirSync(githubDir, { recursive: true });
+  if (!fs.existsSync(instructionsPath)) {
+    fs.writeFileSync(instructionsPath, neohiveAgentRules('Copilot'));
+    console.log('  [ok] VS Code: .github/copilot-instructions.md created');
+  }
+}
+
+// Configure for Antigravity (~/.gemini/antigravity/mcp_config.json + skill)
+function setupAntigravity(cwd) {
+  const antigravityDir = path.join(os.homedir(), '.gemini', 'antigravity');
+  const mcpPath = path.join(antigravityDir, 'mcp_config.json');
+  if (!fs.existsSync(antigravityDir)) fs.mkdirSync(antigravityDir, { recursive: true });
+
+  let config = { mcpServers: {} };
+  if (fs.existsSync(mcpPath)) {
+    try {
+      // Strip JS-style comments before parsing (Antigravity writes JSONC)
+      const raw = fs.readFileSync(mcpPath, 'utf8').replace(/\/\/[^\n]*/g, '');
+      config = JSON.parse(raw);
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch {
+      fs.copyFileSync(mcpPath, mcpPath + '.backup');
+      console.log('  [warn] Existing mcp_config.json was invalid — backed up');
+    }
+  }
+
+  const abDataDir = path.join(path.resolve(cwd), '.neohive').replace(/\\/g, '/');
+
+  config.mcpServers['neohive'] = {
+    command: 'npx',
+    args: ['-y', 'neohive', 'mcp'],
+    cwd: cwd,
+    env: { NEOHIVE_DATA_DIR: abDataDir },
+  };
+
+  fs.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+  console.log('  [ok] Antigravity: ~/.gemini/antigravity/mcp_config.json updated');
+
+  // Write skill
+  const skillDir = path.join(cwd, '.agent', 'skills', 'neohive');
+  if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillPath)) {
+    fs.writeFileSync(skillPath, neohiveAgentRules('Gemini'));
+    console.log('  [ok] Antigravity: .agent/skills/neohive/SKILL.md created');
+  }
+}
+
+function neohiveAgentRules(defaultName) {
+  return `# Neohive Agent
+
+You are a Neohive team agent. Follow these rules every session.
+
+## On session start — always do this first
+
+1. Call \`register\` with your assigned name (e.g. \`register(name="${defaultName}")\`)
+2. Call \`get_briefing\` to load project context and active work
+3. Call \`listen\` to wait for messages from the Coordinator
+
+Do NOT explore the codebase or take initiative before completing these 3 steps.
+
+## Core rules
+
+- **After every action** — call \`listen()\`. This is how you receive your next task.
+- **Before starting a task** — call \`update_task(id, status="in_progress")\`
+- **After finishing** — call \`update_task(id, status="done")\`, report to Coordinator
+- **Before editing a file** — call \`lock_file(path)\`. Call \`unlock_file(path)\` when done.
+- **Check tasks first** — call \`list_tasks()\` before starting anything. Never take another agent's task.
+- **Keep messages short** — 2–3 paragraphs max. Lead with what changed, then files, then decisions.
+
+## Workflow loop
+
+\`\`\`
+register → get_briefing → listen → [receive task] → update_task(in_progress)
+→ do work → update_task(done) → send_message(Coordinator, summary) → listen
+\`\`\`
+
+Never exit the listen loop.
+
+## Available MCP tools (neohive server)
+
+**Messaging:** \`register\`, \`send_message\`, \`broadcast\`, \`listen\`, \`check_messages\`, \`get_history\`
+**Tasks:** \`create_task\`, \`update_task\`, \`list_tasks\`
+**Workflows:** \`create_workflow\`, \`advance_workflow\`, \`workflow_status\`
+**Workspaces:** \`workspace_write\`, \`workspace_read\`, \`workspace_list\`
+`;
 }
 
 // Configure for Codex CLI (uses .codex/config.toml)
@@ -160,17 +370,17 @@ function setupCodex(serverPath, cwd) {
     fs.copyFileSync(configPath, configPath + '.backup');
   }
 
-  // Only add if not already present
-  if (!config.includes('[mcp_servers.neohive]')) {
-    const tomlBlock = `
-[mcp_servers.neohive]
-command = "node"
-args = [${JSON.stringify(serverPath)}]
-timeout = 300
-`;
-    config += tomlBlock;
-    fs.writeFileSync(configPath, config);
-  }
+  const abDataDir = path.join(path.resolve(cwd), '.neohive').replace(/\\/g, '/');
+  const envSection =
+    `[mcp_servers.neohive.env]\nNEOHIVE_DATA_DIR = ${JSON.stringify(abDataDir)}\n`;
+  const hadNeohive = config.includes('[mcp_servers.neohive]');
+  config = upsertNeohiveMcpInToml(config, {
+    command: mcpNodeCommand(),
+    serverPath,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
+    envSection: hadNeohive ? undefined : envSection,
+  });
+  fs.writeFileSync(configPath, config);
 
   console.log('  [ok] Codex CLI: .codex/config.toml updated');
 }
@@ -200,10 +410,10 @@ function setupCursor(serverPath, cwd) {
   }
 
   mcpConfig.mcpServers['neohive'] = {
-    command: 'node',
+    command: mcpNodeCommand(),
     args: [serverPath],
     env: { NEOHIVE_DATA_DIR: abDataDir },
-    timeout: 300,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
   };
 
   fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + '\n');
@@ -315,10 +525,10 @@ async function processMessages() {
 
 // Main loop
 register();
-const hb = setInterval(heartbeat, 10000);
+const hb = setInterval(heartbeat, CLI_CONFIG.OLLAMA_HEARTBEAT_MS);
 hb.unref();
 console.log('[' + name + '] Listening for messages... (Ctrl+C to stop)');
-setInterval(processMessages, 2000);
+setInterval(processMessages, CLI_CONFIG.OLLAMA_POLL_MS);
 
 // Cleanup on exit
 process.on('SIGINT', function() { console.log('\\n[' + name + '] Shutting down.'); process.exit(0); });
@@ -359,8 +569,12 @@ function init() {
     targets = ['codex'];
   } else if (flag === '--cursor') {
     targets = ['cursor'];
+  } else if (flag === '--vscode') {
+    targets = ['vscode'];
+  } else if (flag === '--antigravity') {
+    targets = ['antigravity'];
   } else if (flag === '--all') {
-    targets = ['claude', 'gemini', 'codex', 'cursor'];
+    targets = ['claude', 'gemini', 'codex', 'cursor', 'vscode', 'antigravity'];
   } else if (flag === '--ollama') {
     const ollama = detectOllama();
     if (!ollama.installed) {
@@ -389,10 +603,12 @@ function init() {
 
   for (const target of targets) {
     switch (target) {
-      case 'claude': setupClaude(serverPath, cwd); break;
-      case 'gemini': setupGemini(serverPath, cwd); break;
-      case 'codex':  setupCodex(serverPath, cwd);  break;
-      case 'cursor': setupCursor(serverPath, cwd); break;
+      case 'claude':      setupClaude(serverPath, cwd);   break;
+      case 'gemini':      setupGemini(serverPath, cwd);   break;
+      case 'codex':       setupCodex(serverPath, cwd);    break;
+      case 'cursor':      setupCursor(serverPath, cwd);   break;
+      case 'vscode':      setupVSCode(cwd);               break;
+      case 'antigravity': setupAntigravity(cwd);          break;
     }
   }
 
@@ -420,6 +636,9 @@ function init() {
       ? '  Neohive is ready! Restart Cursor (or reload MCP tools) and restart any terminal CLIs you use.'
       : '  Neohive is ready! Restart your CLI to pick up the MCP tools.'
   );
+  console.log('  MCP server command is your current Node binary (works when the IDE has no Volta/nvm in PATH):');
+  console.log('    ' + mcpNodeCommand());
+  console.log('  Re-run `npx neohive init` after switching machines or Node versions.');
   console.log('');
 
   // Show template if --template was provided
@@ -442,7 +661,7 @@ function init() {
     console.log('  Tip: Use "npx neohive init --template pair" for ready-made prompts.');
     console.log('');
     console.log('  \x1b[1m  Monitor:\x1b[0m');
-    console.log('    npx neohive dashboard');
+    console.log('    npx neohive dashboard   → http://localhost:3000 (set NEOHIVE_PORT to change)');
     console.log('    npx neohive status');
     console.log('    npx neohive doctor');
     console.log('');
@@ -610,6 +829,14 @@ function cliMsg() {
     process.exit(1);
   }
   const text = textParts.join(' ');
+  if (text.length > CLI_CONFIG.MSG_MAX_CHARS) {
+    console.error(`  Message text exceeds maximum length of ${CLI_CONFIG.MSG_MAX_CHARS} characters.`);
+    process.exit(1);
+  }
+  if (!text.trim().length) {
+    console.error('  Message text cannot be empty or whitespace only.');
+    process.exit(1);
+  }
   const dir = resolveDataDirCli();
   if (!fs.existsSync(dir)) {
     console.error('  No .neohive/ directory found. Run "npx neohive init" first.');
@@ -625,12 +852,16 @@ function cliMsg() {
     timestamp: new Date().toISOString(),
   };
 
-  const messagesFile = path.join(dir, 'messages.jsonl');
-  const historyFile = path.join(dir, 'history.jsonl');
-  fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
-  fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
-
-  console.log('  Message sent to ' + recipient + ': ' + text);
+  try {
+    const messagesFile = path.join(dir, 'messages.jsonl');
+    const historyFile = path.join(dir, 'history.jsonl');
+    fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
+    fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
+    console.log('  Message sent to ' + recipient + ': ' + text);
+  } catch (e) {
+    console.error('  Failed to send message: ' + e.message);
+    process.exit(1);
+  }
 }
 
 function cliStatus() {
@@ -991,6 +1222,10 @@ switch (command) {
   case 'templates':
     listTemplates();
     break;
+  case 'mcp':
+    // Start stdio MCP server — used as the command in all MCP configs: npx neohive mcp
+    require('./server.js');
+    break;
   case 'serve':
     serve();
     break;