neohive 6.0.2 → 6.1.0

package/lib/github-sync.js

@@ -0,0 +1,291 @@
+'use strict';
+
+// GitHub Projects v2 sync — mirrors neohive tasks to a GitHub Project board.
+// Uses GraphQL API with draft issues. One-way sync (neohive → GitHub).
+//
+// Configuration (any of these sources):
+//   1. GITHUB_TOKEN + GITHUB_PROJECT_ID env vars
+//   2. .neohive/config.json → { github: { token, project_id, org, status_field_id, status_options } }
+//
+// When unconfigured, all functions are no-ops (graceful degradation).
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { DATA_DIR } = require('./config');
+const log = require('./logger');
+
+// --- Config ---
+
+function getGitHubConfig() {
+  const config = { token: null, project_id: null, org: null, status_field_id: null, status_options: {} };
+
+  // Env vars take priority
+  if (process.env.GITHUB_TOKEN) config.token = process.env.GITHUB_TOKEN;
+  if (process.env.GITHUB_PROJECT_ID) config.project_id = process.env.GITHUB_PROJECT_ID;
+
+  // Fall back to .neohive/config.json
+  const configFile = path.join(DATA_DIR, 'config.json');
+  if (fs.existsSync(configFile)) {
+    try {
+      const fileConfig = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      if (fileConfig.github) {
+        if (!config.token && fileConfig.github.token) config.token = fileConfig.github.token;
+        if (!config.project_id && fileConfig.github.project_id) config.project_id = fileConfig.github.project_id;
+        if (fileConfig.github.org) config.org = fileConfig.github.org;
+        if (fileConfig.github.status_field_id) config.status_field_id = fileConfig.github.status_field_id;
+        if (fileConfig.github.status_options) config.status_options = fileConfig.github.status_options;
+      }
+    } catch (e) { log.debug('github-sync: failed to read config:', e.message); }
+  }
+
+  return config;
+}
+
+function isConfigured() {
+  const config = getGitHubConfig();
+  return !!(config.token && config.project_id);
+}
+
+// --- GraphQL client ---
+
+function graphql(token, query, variables) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({ query, variables: variables || {} });
+    const req = https.request({
+      hostname: 'api.github.com',
+      path: '/graphql',
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'neohive-github-sync',
+        'Content-Length': Buffer.byteLength(data),
+      },
+    }, (res) => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(body);
+          if (parsed.errors) {
+            reject(new Error(parsed.errors.map(e => e.message).join('; ')));
+          } else {
+            resolve(parsed);
+          }
+        } catch (e) {
+          reject(new Error('Invalid JSON response from GitHub API'));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(10000, () => { req.destroy(); reject(new Error('GitHub API timeout')); });
+    req.write(data);
+    req.end();
+  });
+}
+
+// --- Sync mapping file ---
+// Tracks neohive task ID → GitHub project item ID mapping
+
+const SYNC_MAP_FILE = path.join(DATA_DIR, 'github-sync-map.json');
+
+function getSyncMap() {
+  if (!fs.existsSync(SYNC_MAP_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(SYNC_MAP_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveSyncMap(map) {
+  fs.writeFileSync(SYNC_MAP_FILE, JSON.stringify(map, null, 2));
+}
+
+// --- Status mapping ---
+
+const DEFAULT_STATUS_MAP = {
+  pending: 'Todo',
+  in_progress: 'In Progress',
+  in_review: 'In Review',
+  done: 'Done',
+  blocked: 'Blocked',
+  blocked_permanent: 'Blocked',
+};
+
+// --- Core sync functions ---
+
+/**
+ * Sync a single task to GitHub Projects.
+ * Creates a draft issue if new, updates status field if existing.
+ * Non-blocking — errors are logged but not thrown.
+ */
+async function syncTask(task) {
+  if (!isConfigured()) return null;
+
+  const config = getGitHubConfig();
+  const syncMap = getSyncMap();
+
+  try {
+    const itemId = syncMap[task.id];
+
+    if (!itemId) {
+      // New task — create draft issue
+      const body = [
+        task.description || '',
+        '',
+        `---`,
+        `Neohive ID: \`${task.id}\``,
+        task.assignee ? `Assignee: ${task.assignee}` : '',
+        `Status: ${task.status}`,
+        `Created by: ${task.created_by || 'unknown'}`,
+      ].filter(Boolean).join('\n');
+
+      const result = await graphql(config.token,
+        `mutation($projectId: ID!, $title: String!, $body: String) {
+          addProjectV2DraftIssue(input: {projectId: $projectId, title: $title, body: $body}) {
+            projectItem { id }
+          }
+        }`,
+        { projectId: config.project_id, title: task.title, body }
+      );
+
+      const newItemId = result.data.addProjectV2DraftIssue.projectItem.id;
+      syncMap[task.id] = newItemId;
+      saveSyncMap(syncMap);
+
+      log.info(`github-sync: created draft issue for task "${task.title}" → ${newItemId}`);
+
+      // Update status field if configured
+      if (config.status_field_id && config.status_options[task.status]) {
+        await updateStatusField(config, newItemId, task.status);
+      }
+
+      return { action: 'created', item_id: newItemId };
+    } else {
+      // Existing task — update status field
+      if (config.status_field_id && config.status_options[task.status]) {
+        await updateStatusField(config, itemId, task.status);
+        log.info(`github-sync: updated status for "${task.title}" → ${task.status}`);
+        return { action: 'updated', item_id: itemId, status: task.status };
+      }
+      return { action: 'no_update', item_id: itemId, reason: 'status field not configured' };
+    }
+  } catch (e) {
+    log.warn(`github-sync: failed to sync task "${task.title}":`, e.message);
+    return { action: 'error', error: e.message };
+  }
+}
+
+async function updateStatusField(config, itemId, status) {
+  const optionId = config.status_options[status];
+  if (!optionId) return;
+
+  await graphql(config.token,
+    `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId, itemId: $itemId,
+        fieldId: $fieldId, value: {singleSelectOptionId: $optionId}
+      }) { projectV2Item { id } }
+    }`,
+    { projectId: config.project_id, itemId, fieldId: config.status_field_id, optionId }
+  );
+}
+
+/**
+ * Sync all tasks from tasks.json to GitHub Projects.
+ * Creates missing items, updates status for existing ones.
+ */
+async function syncAllTasks() {
+  if (!isConfigured()) return { error: 'GitHub sync not configured. Set GITHUB_TOKEN and GITHUB_PROJECT_ID.' };
+
+  const tasksFile = path.join(DATA_DIR, 'tasks.json');
+  if (!fs.existsSync(tasksFile)) return { error: 'No tasks.json found' };
+
+  let tasks;
+  try { tasks = JSON.parse(fs.readFileSync(tasksFile, 'utf8')); } catch { return { error: 'Invalid tasks.json' }; }
+
+  const results = { created: 0, updated: 0, errors: 0, skipped: 0 };
+  for (const task of tasks) {
+    const result = await syncTask(task);
+    if (!result) { results.skipped++; continue; }
+    if (result.action === 'created') results.created++;
+    else if (result.action === 'updated') results.updated++;
+    else if (result.action === 'error') results.errors++;
+    else results.skipped++;
+  }
+
+  return { success: true, ...results, total: tasks.length };
+}
+
+/**
+ * Discover project fields — helper for initial setup.
+ * Returns field IDs and single-select options for status mapping.
+ */
+async function discoverFields() {
+  if (!isConfigured()) return { error: 'GitHub sync not configured.' };
+
+  const config = getGitHubConfig();
+  const result = await graphql(config.token,
+    `query($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          title
+          fields(first: 20) {
+            nodes {
+              ... on ProjectV2FieldCommon { id name }
+              ... on ProjectV2SingleSelectField {
+                id name
+                options { id name }
+              }
+            }
+          }
+        }
+      }
+    }`,
+    { projectId: config.project_id }
+  );
+
+  const project = result.data.node;
+  return {
+    project_title: project.title,
+    fields: project.fields.nodes.map(f => ({
+      id: f.id,
+      name: f.name,
+      ...(f.options && { options: f.options }),
+    })),
+    hint: 'Find the Status field, copy its id to github.status_field_id in .neohive/config.json. Map each status option id to github.status_options: { "pending": "OPTION_ID", "in_progress": "OPTION_ID", ... }',
+  };
+}
+
+/**
+ * Get sync status — how many tasks are synced, unsynced, stale.
+ */
+function getSyncStatus() {
+  const configured = isConfigured();
+  const syncMap = getSyncMap();
+  const tasksFile = path.join(DATA_DIR, 'tasks.json');
+  let tasks = [];
+  if (fs.existsSync(tasksFile)) {
+    try { tasks = JSON.parse(fs.readFileSync(tasksFile, 'utf8')); } catch {}
+  }
+
+  const synced = tasks.filter(t => syncMap[t.id]).length;
+  const unsynced = tasks.filter(t => !syncMap[t.id]).length;
+
+  return {
+    configured,
+    total_tasks: tasks.length,
+    synced,
+    unsynced,
+    sync_map_entries: Object.keys(syncMap).length,
+    status_mapping: DEFAULT_STATUS_MAP,
+  };
+}
+
+module.exports = {
+  isConfigured,
+  getGitHubConfig,
+  syncTask,
+  syncAllTasks,
+  discoverFields,
+  getSyncStatus,
+  DEFAULT_STATUS_MAP,
+};

package/lib/hooks.js

@@ -0,0 +1,173 @@
+'use strict';
+
+// Event hooks system — agents subscribe to events and get auto-notified via system messages.
+// Hooks registry stored in .neohive/hooks.json.
+//
+// Supported events:
+//   task.status_changed  — fires when any task changes status (filter by status, assignee)
+//   agent.idle           — fires when an agent is idle for >2 min
+//   agent.stuck          — fires when an agent is unresponsive for >10 min
+//   workflow.advanced    — fires when a workflow step completes
+//   review.submitted     — fires when a review is submitted
+
+const fs = require('fs');
+const path = require('path');
+const { DATA_DIR } = require('./config');
+const log = require('./logger');
+
+const HOOKS_FILE = path.join(DATA_DIR, 'hooks.json');
+const VALID_EVENTS = ['task.status_changed', 'agent.idle', 'agent.stuck', 'workflow.advanced', 'review.submitted', 'rule.changed'];
+
+// --- Registry ---
+
+function getHooks() {
+  if (!fs.existsSync(HOOKS_FILE)) return [];
+  try { return JSON.parse(fs.readFileSync(HOOKS_FILE, 'utf8')); } catch { return []; }
+}
+
+function saveHooks(hooks) {
+  fs.writeFileSync(HOOKS_FILE, JSON.stringify(hooks, null, 2));
+}
+
+/**
+ * Subscribe an agent to an event.
+ * @param {string} agent - agent name
+ * @param {string} event - event name (e.g. 'task.status_changed')
+ * @param {object} filter - optional filter (e.g. { status: 'done', assignee: 'Nick' })
+ * @returns {{ success, hook_id } | { error }}
+ */
+function subscribe(agent, event, filter) {
+  if (!VALID_EVENTS.includes(event)) {
+    return { error: `Invalid event. Must be one of: ${VALID_EVENTS.join(', ')}` };
+  }
+
+  const hooks = getHooks();
+
+  // Prevent duplicate subscriptions
+  const existing = hooks.find(h => h.agent === agent && h.event === event &&
+    JSON.stringify(h.filter || {}) === JSON.stringify(filter || {}));
+  if (existing) {
+    return { success: true, hook_id: existing.id, message: 'Already subscribed to this event.' };
+  }
+
+  if (hooks.length >= 500) return { error: 'Hook limit reached (max 500).' };
+
+  const hook = {
+    id: 'hook_' + Date.now().toString(36) + Math.random().toString(36).substring(2, 6),
+    agent,
+    event,
+    filter: filter || {},
+    created_at: new Date().toISOString(),
+  };
+  hooks.push(hook);
+  saveHooks(hooks);
+
+  return { success: true, hook_id: hook.id, event, filter: hook.filter, message: `Subscribed to ${event}. You will receive system messages when this event fires.` };
+}
+
+/**
+ * Unsubscribe from a hook by ID, or all hooks for an agent.
+ */
+function unsubscribe(agent, hookId) {
+  const hooks = getHooks();
+  if (hookId) {
+    const idx = hooks.findIndex(h => h.id === hookId && h.agent === agent);
+    if (idx === -1) return { error: 'Hook not found or not owned by you.' };
+    hooks.splice(idx, 1);
+    saveHooks(hooks);
+    return { success: true, message: 'Unsubscribed.' };
+  }
+  // Unsubscribe all for this agent
+  const before = hooks.length;
+  const filtered = hooks.filter(h => h.agent !== agent);
+  saveHooks(filtered);
+  return { success: true, removed: before - filtered.length, message: `Removed ${before - filtered.length} hook(s).` };
+}
+
+/**
+ * List hooks for an agent (or all if agent is null).
+ */
+function listHooks(agent) {
+  const hooks = getHooks();
+  const filtered = agent ? hooks.filter(h => h.agent === agent) : hooks;
+  return {
+    count: filtered.length,
+    hooks: filtered.map(h => ({ id: h.id, agent: h.agent, event: h.event, filter: h.filter, created_at: h.created_at })),
+  };
+}
+
+/**
+ * Emit an event — checks all subscriptions and returns list of agents to notify.
+ * Caller (fireEvent in server.js) is responsible for actually sending the messages.
+ *
+ * @param {string} event - event name
+ * @param {object} data - event data (varies by event type)
+ * @returns {Array<{ agent, message }>} - agents to notify with formatted messages
+ */
+function emit(event, data) {
+  const hooks = getHooks();
+  const subscribers = hooks.filter(h => h.event === event);
+  if (subscribers.length === 0) return [];
+
+  const notifications = [];
+
+  for (const hook of subscribers) {
+    // Apply filters
+    if (!matchesFilter(hook.filter, data)) continue;
+    // Don't notify the agent that triggered the event
+    if (data._source_agent && data._source_agent === hook.agent) continue;
+
+    const message = formatEventMessage(event, data);
+    if (message) {
+      notifications.push({ agent: hook.agent, message });
+    }
+  }
+
+  return notifications;
+}
+
+function matchesFilter(filter, data) {
+  if (!filter || Object.keys(filter).length === 0) return true;
+  for (const [key, value] of Object.entries(filter)) {
+    if (data[key] !== undefined && data[key] !== value) return false;
+  }
+  return true;
+}
+
+function formatEventMessage(event, data) {
+  switch (event) {
+    case 'task.status_changed':
+      return `[HOOK] Task "${data.title || data.task_id}" status → ${data.status}` +
+        (data.assignee ? ` (assignee: ${data.assignee})` : '') +
+        (data.changed_by ? ` by ${data.changed_by}` : '');
+    case 'agent.idle':
+      return `[HOOK] Agent ${data.agent} has been idle for ${Math.round((data.idle_seconds || 0) / 60)} minutes.`;
+    case 'agent.stuck':
+      return `[HOOK] Agent ${data.agent} is unresponsive (${Math.round((data.idle_seconds || 0) / 60)}+ min). ${data.tasks_reassigned || 0} task(s) may need reassignment.`;
+    case 'workflow.advanced':
+      return `[HOOK] Workflow "${data.workflow_name}" step ${data.step_id} completed` +
+        (data.progress ? ` (${data.progress})` : '') +
+        (data.next_assignee ? `. Next: ${data.next_assignee}` : '');
+    case 'review.submitted':
+      return `[HOOK] Review "${data.file}" ${data.status} by ${data.reviewer}` +
+        (data.feedback ? `: ${data.feedback.substring(0, 100)}` : '');
+    case 'rule.changed': {
+      const action = data.action || 'changed';
+      const scope = data.scope_role || data.scope_provider || data.scope_agent
+        ? ` (scoped to: ${[data.scope_role, data.scope_provider, data.scope_agent].filter(Boolean).join(', ')})`
+        : '';
+      return `[HOOK] Rule ${action} by ${data.changed_by || 'unknown'}: "${(data.text || data.rule_id || '').substring(0, 100)}"${scope}. Call get_briefing() to load updated rules.`;
+    }
+    default:
+      return `[HOOK] ${event}: ${JSON.stringify(data).substring(0, 200)}`;
+  }
+}
+
+module.exports = {
+  VALID_EVENTS,
+  subscribe,
+  unsubscribe,
+  listHooks,
+  emit,
+  getHooks,
+};

package/lib/ide-activity.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const WORKING_STALE_MS = 10000;
+
+/**
+ * Read IDE liveness hint written by vscode-extension (ide-activity-{agent}.json).
+ * v2 fields: focused, ide_idle, extension_online, working, shell_working, last_tool_call, timestamp.
+ * @param {string} dataDir - .neohive directory
+ * @param {string} agentName
+ */
+function readIdeActivity(dataDir, agentName) {
+  if (!dataDir || !agentName || !/^[a-zA-Z0-9_-]{1,20}$/.test(agentName)) return null;
+  const f = path.join(dataDir, `ide-activity-${agentName}.json`);
+  if (!fs.existsSync(f)) return null;
+  try {
+    const j = JSON.parse(fs.readFileSync(f, 'utf8'));
+    return {
+      focused: j.focused === true,
+      ide_idle: j.ide_idle === true,
+      extension_online: j.extension_online !== false,
+      working: j.working === true,
+      shell_working: j.shell_working === true,
+      last_tool_call: typeof j.last_tool_call === 'string' ? j.last_tool_call : null,
+      timestamp: typeof j.timestamp === 'string' ? j.timestamp : null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read last_stdin_activity from heartbeat-{agent}.json (written by server.js stdin tracker).
+ * @param {string} dataDir
+ * @param {string} agentName
+ * @returns {string|null} ISO timestamp or null
+ */
+function readStdinActivity(dataDir, agentName) {
+  if (!dataDir || !agentName) return null;
+  const f = path.join(dataDir, `heartbeat-${agentName}.json`);
+  try {
+    const j = JSON.parse(fs.readFileSync(f, 'utf8'));
+    return typeof j.last_stdin_activity === 'string' ? j.last_stdin_activity : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Layer IDE extension + stdin hints on list_agents / apiAgents entries (mutates entry).
+ *
+ * Priority order:
+ *   1. extension_online: false           → offline
+ *   2. listening_since set (from agent)  → listening  (never override)
+ *   3. working OR shell_working OR       → working
+ *      stdin activity < 10s OR
+ *      last_tool_call < 10s
+ *   4. ide_idle: true                    → idle
+ *   5. default                           → keep existing status
+ *
+ * @param {object} entry - built agent row
+ * @param {ReturnType<typeof readIdeActivity>} ide
+ * @param {object} [opts]
+ * @param {string} [opts.dataDir] - .neohive dir for reading heartbeat stdin
+ * @param {string} [opts.agentName]
+ */
+function applyIdeActivityHint(entry, ide, opts) {
+  if (!ide || !entry) return;
+
+  entry.ide_activity = {
+    focused: ide.focused,
+    ide_idle: ide.ide_idle,
+    extension_online: ide.extension_online,
+    working: ide.working,
+    shell_working: ide.shell_working,
+    last_tool_call: ide.last_tool_call,
+    timestamp: ide.timestamp,
+  };
+
+  // Priority 1: extension offline → agent offline
+  if (ide.extension_online === false) {
+    entry.alive = false;
+    entry.status = 'offline';
+    entry.idle_seconds = null;
+    entry.is_listening = false;
+    return;
+  }
+
+  // Priority 2: listening (set by server via listen()) → never override
+  if (entry.is_listening) return;
+
+  // Check stdin freshness from heartbeat
+  let stdinRecent = false;
+  if (opts && opts.dataDir && opts.agentName) {
+    const stdinTs = readStdinActivity(opts.dataDir, opts.agentName);
+    if (stdinTs) {
+      stdinRecent = (Date.now() - new Date(stdinTs).getTime()) < WORKING_STALE_MS;
+    }
+  }
+
+  // Check tool call freshness
+  let toolCallRecent = false;
+  if (ide.last_tool_call) {
+    toolCallRecent = (Date.now() - new Date(ide.last_tool_call).getTime()) < WORKING_STALE_MS;
+  }
+
+  // Priority 3: active work signals → working
+  if ((ide.working || ide.shell_working || stdinRecent || toolCallRecent) && entry.alive) {
+    entry.status = 'working';
+    return;
+  }
+
+  // Priority 4: IDE idle → idle
+  if (ide.ide_idle && entry.alive) {
+    entry.status = 'idle';
+  }
+}
+
+module.exports = { readIdeActivity, readStdinActivity, applyIdeActivityHint };

package/lib/resolve-server-data-dir.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function normalizeNeohiveDataDirString(raw, workspaceRoot) {
+  if (raw == null || typeof raw !== 'string') return null;
+  let d = raw.trim();
+  if (!d) return null;
+  d = d.replace(/\$\{workspaceFolder\}/gi, workspaceRoot);
+  return path.isAbsolute(d) ? path.resolve(d) : path.resolve(workspaceRoot, d);
+}
+
+/** Same candidate files as dashboard.js readNeohiveDataDirFromMcpConfigs */
+function readNeohiveDataDirFromMcpConfigs(projectRoot) {
+  const candidates = [
+    path.join(projectRoot, '.cursor', 'mcp.json'),
+    path.join(projectRoot, '.mcp.json'),
+    path.join(projectRoot, '.gemini', 'settings.json'),
+  ];
+  for (const filePath of candidates) {
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const j = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      const nh = j.mcpServers && j.mcpServers.neohive;
+      const raw = nh && nh.env && nh.env.NEOHIVE_DATA_DIR;
+      const out = normalizeNeohiveDataDirString(raw, projectRoot);
+      if (out) return out;
+    } catch {
+      /* ignore */
+    }
+  }
+  return null;
+}
+
+function findDataDirByWalkingUpFrom(startDir) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  for (let depth = 0; depth < 32 && dir !== root; depth++) {
+    const fromMcp = readNeohiveDataDirFromMcpConfigs(dir);
+    if (fromMcp) return fromMcp;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/** User-level Cursor MCP may define neohive with an absolute data dir */
+function readNeohiveDirFromUserCursorMcp() {
+  const userMcp = path.join(os.homedir(), '.cursor', 'mcp.json');
+  if (!fs.existsSync(userMcp)) return null;
+  try {
+    const j = JSON.parse(fs.readFileSync(userMcp, 'utf8'));
+    const nh = j.mcpServers && j.mcpServers.neohive;
+    const raw = nh && nh.env && nh.env.NEOHIVE_DATA_DIR;
+    if (raw == null || typeof raw !== 'string') return null;
+    const d = raw.trim();
+    if (!d || /\$\{workspaceFolder\}/i.test(d)) return null;
+    return path.resolve(d);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Neohive data directory for the MCP / CLI process.
+ * Cursor often spawns MCP with cwd=user home and omits NEOHIVE_DATA_DIR in the child env.
+ * We mirror dashboard resolution: walk ancestors of cwd for MCP configs, then package sibling,
+ * then ~/.cursor/mcp.json with an absolute path, then cwd/.neohive.
+ *
+ * @param {string} serverJsDir - __dirname of server.js (the agent-bridge folder)
+ */
+function resolveDataDirForServer(serverJsDir) {
+  const raw = process.env.NEOHIVE_DATA_DIR || process.env.NEOHIVE_DATA;
+  if (raw != null && String(raw).trim() !== '') {
+    return path.resolve(String(raw).trim());
+  }
+
+  const fromWalk = findDataDirByWalkingUpFrom(process.cwd());
+  if (fromWalk) return fromWalk;
+
+  const parent = path.join(serverJsDir, '..');
+  if (fs.existsSync(path.join(parent, '.cursor', 'mcp.json'))) {
+    return path.join(parent, '.neohive');
+  }
+  if (fs.existsSync(path.join(serverJsDir, '.cursor', 'mcp.json'))) {
+    return path.join(serverJsDir, '.neohive');
+  }
+
+  const fromUser = readNeohiveDirFromUserCursorMcp();
+  if (fromUser) return fromUser;
+
+  return path.join(process.cwd(), '.neohive');
+}
+
+module.exports = { resolveDataDirForServer };