@softerist/heuristic-mcp 3.0.15 → 3.0.16

package/features/package-version.js

@@ -0,0 +1,302 @@
+/**
+ * Package Version Lookup Tool
+ *
+ * Fetches the latest version of packages from various registries.
+ * Supports npm, PyPI, crates.io, Maven, Go, RubyGems, NuGet, Packagist, Hex, pub.dev, and more.
+ */
+
+// Registry configurations with their API endpoints and response parsers
+const REGISTRIES = {
+  npm: {
+    name: 'npm',
+    pattern: /^(?:npm:)?(.+)$/,
+    url: (pkg) => `https://registry.npmjs.org/${encodeURIComponent(pkg)}/latest`,
+    parse: (data) => data.version,
+    detect: (pkg) =>
+      pkg.startsWith('@') || /^[a-z0-9][-a-z0-9._]*$/i.test(pkg.replace(/^npm:/, '')),
+  },
+  pypi: {
+    name: 'PyPI',
+    pattern: /^(?:pip:|pypi:)(.+)$/,
+    url: (pkg) => `https://pypi.org/pypi/${encodeURIComponent(pkg)}/json`,
+    parse: (data) => data.info.version,
+    detect: () => false, // Requires explicit prefix
+  },
+  crates: {
+    name: 'crates.io',
+    pattern: /^(?:cargo:|crates:|rust:)(.+)$/,
+    url: (pkg) => `https://crates.io/api/v1/crates/${encodeURIComponent(pkg)}`,
+    parse: (data) => data.crate.max_version,
+    headers: { 'User-Agent': 'heuristic-mcp/1.0' },
+    detect: () => false,
+  },
+  go: {
+    name: 'Go',
+    pattern: /^(?:go:)(.+)$/,
+    url: (pkg) => `https://proxy.golang.org/${encodeURIComponent(pkg)}/@latest`,
+    parse: (data) => data.Version,
+    detect: (pkg) => pkg.includes('/') && pkg.includes('.'),
+  },
+  rubygems: {
+    name: 'RubyGems',
+    pattern: /^(?:gem:|ruby:)(.+)$/,
+    url: (pkg) => `https://rubygems.org/api/v1/gems/${encodeURIComponent(pkg)}.json`,
+    parse: (data) => data.version,
+    detect: () => false,
+  },
+  nuget: {
+    name: 'NuGet',
+    pattern: /^(?:nuget:|dotnet:)(.+)$/,
+    url: (pkg) =>
+      `https://api.nuget.org/v3-flatcontainer/${encodeURIComponent(pkg.toLowerCase())}/index.json`,
+    parse: (data) => data.versions[data.versions.length - 1],
+    detect: () => false,
+  },
+  packagist: {
+    name: 'Packagist',
+    pattern: /^(?:composer:|php:)(.+)$/,
+    url: (pkg) => `https://repo.packagist.org/p2/${encodeURIComponent(pkg)}.json`,
+    parse: (data) => {
+      const pkgName = Object.keys(data.packages)[0];
+      const versions = data.packages[pkgName];
+      // Filter out dev versions and get latest stable
+      const stable = versions.find((v) => !v.version.includes('dev'));
+      return stable ? stable.version : versions[0].version;
+    },
+    detect: (pkg) => pkg.includes('/'),
+  },
+  hex: {
+    name: 'Hex',
+    pattern: /^(?:hex:|elixir:|mix:)(.+)$/,
+    url: (pkg) => `https://hex.pm/api/packages/${encodeURIComponent(pkg)}`,
+    parse: (data) => {
+      const releases = data.releases;
+      return releases.length > 0 ? releases[0].version : null;
+    },
+    detect: () => false,
+  },
+  pub: {
+    name: 'pub.dev',
+    pattern: /^(?:pub:|dart:|flutter:)(.+)$/,
+    url: (pkg) => `https://pub.dev/api/packages/${encodeURIComponent(pkg)}`,
+    parse: (data) => data.latest.version,
+    detect: () => false,
+  },
+  maven: {
+    name: 'Maven Central',
+    pattern: /^(?:maven:|java:)(.+)$/,
+    url: (pkg) => {
+      // Maven packages are in format group:artifact or group/artifact
+      const [group, artifact] = pkg.includes(':') ? pkg.split(':') : pkg.split('/');
+      if (!artifact) return null;
+      return `https://search.maven.org/solrsearch/select?q=g:${encodeURIComponent(group)}+AND+a:${encodeURIComponent(artifact)}&rows=1&wt=json`;
+    },
+    parse: (data) => {
+      if (data.response.docs.length === 0) return null;
+      return data.response.docs[0].latestVersion;
+    },
+    detect: (pkg) => pkg.includes(':') || (pkg.includes('.') && pkg.includes('/')),
+  },
+  homebrew: {
+    name: 'Homebrew',
+    pattern: /^(?:brew:|homebrew:)(.+)$/,
+    url: (pkg) => `https://formulae.brew.sh/api/formula/${encodeURIComponent(pkg)}.json`,
+    parse: (data) => data.versions.stable,
+    detect: () => false,
+  },
+  conda: {
+    name: 'Conda',
+    pattern: /^(?:conda:)(.+)$/,
+    url: (pkg) =>
+      `https://api.anaconda.org/package/conda-forge/${encodeURIComponent(pkg)}`,
+    parse: (data) => data.latest_version,
+    detect: () => false,
+  },
+};
+
+/**
+ * Detect the registry for a package based on its name or prefix
+ */
+function detectRegistry(packageName) {
+  // Check for explicit prefixes first
+  for (const [key, registry] of Object.entries(REGISTRIES)) {
+    if (registry.pattern.test(packageName) && key !== 'npm') {
+      const match = packageName.match(registry.pattern);
+      if (match) {
+        return { registry, cleanName: match[1] };
+      }
+    }
+  }
+
+  // Try to detect based on package name patterns
+  for (const registry of Object.values(REGISTRIES)) {
+    if (registry.detect(packageName)) {
+      const match = packageName.match(registry.pattern);
+      return { registry, cleanName: match ? match[1] : packageName };
+    }
+  }
+
+  // Default to npm
+  const npmMatch = packageName.match(REGISTRIES.npm.pattern);
+  return { registry: REGISTRIES.npm, cleanName: npmMatch ? npmMatch[1] : packageName };
+}
+
+/**
+ * Fetch the latest version of a package from its registry
+ */
+async function fetchPackageVersion(packageName, timeoutMs = 10000) {
+  const { registry, cleanName } = detectRegistry(packageName);
+
+  const url = registry.url(cleanName);
+  if (!url) {
+    return {
+      success: false,
+      error: `Invalid package format for ${registry.name}: ${cleanName}`,
+      registry: registry.name,
+    };
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const headers = {
+      Accept: 'application/json',
+      ...(registry.headers || {}),
+    };
+
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        return {
+          success: false,
+          error: `Package "${cleanName}" not found on ${registry.name}`,
+          registry: registry.name,
+        };
+      }
+      return {
+        success: false,
+        error: `${registry.name} returned status ${response.status}`,
+        registry: registry.name,
+      };
+    }
+
+    const data = await response.json();
+    const version = registry.parse(data);
+
+    if (!version) {
+      return {
+        success: false,
+        error: `Could not parse version from ${registry.name} response`,
+        registry: registry.name,
+      };
+    }
+
+    return {
+      success: true,
+      package: cleanName,
+      version,
+      registry: registry.name,
+    };
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return {
+        success: false,
+        error: `Request to ${registry.name} timed out`,
+        registry: registry.name,
+      };
+    }
+    return {
+      success: false,
+      error: `Failed to fetch from ${registry.name}: ${error.message}`,
+      registry: registry.name,
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Get supported registries list for help text
+ */
+function getSupportedRegistries() {
+  return Object.entries(REGISTRIES).map(([key, reg]) => ({
+    key,
+    name: reg.name,
+    prefix: reg.pattern.source.match(/\?:([^)]+)\)/)?.[1] || key + ':',
+  }));
+}
+
+// MCP Tool definition
+export function getToolDefinition() {
+  return {
+    name: 'e_check_package_version',
+    description:
+      'Fetches the latest version of a package from its official registry. Supports npm, PyPI, crates.io, Maven, Go, RubyGems, NuGet, Packagist, Hex, pub.dev, Homebrew, and Conda. Use prefix like "pip:requests" for non-npm packages.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        package: {
+          type: 'string',
+          description:
+            'Package name, optionally prefixed with registry (e.g., "lodash", "pip:requests", "cargo:serde", "go:github.com/gin-gonic/gin")',
+        },
+      },
+      required: ['package'],
+    },
+    annotations: {
+      title: 'Check Package Version',
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true, // Makes external network requests
+    },
+  };
+}
+
+// Tool handler
+export async function handleToolCall(request) {
+  const args = request.params?.arguments || {};
+  const packageName = args.package;
+
+  if (!packageName || typeof packageName !== 'string' || packageName.trim() === '') {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Error: Please provide a package name.',
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const result = await fetchPackageVersion(packageName.trim());
+
+  if (result.success) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `**${result.package}** (${result.registry})\n\nLatest version: \`${result.version}\``,
+        },
+      ],
+    };
+  } else {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${result.error}`,
+        },
+      ],
+    };
+  }
+}
+
+// Export for testing
+export { fetchPackageVersion, detectRegistry, getSupportedRegistries, REGISTRIES };

package/features/register.js

@@ -0,0 +1,408 @@
+import fs from 'fs/promises';
+import { writeFileSync } from 'fs';
+
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import {
+  parseJsonc,
+  upsertMcpServerEntryInText,
+  upsertMcpServerEntryInToml,
+} from '../lib/settings-editor.js';
+
+function getUserHomeDir() {
+  if (process.platform === 'win32' && process.env.USERPROFILE) {
+    return process.env.USERPROFILE;
+  }
+  return os.homedir();
+}
+
+// Detect which IDE is running the install
+function detectCurrentIDE() {
+  // Check environment variables to determine which IDE is running
+  if (process.env.ANTIGRAVITY_AGENT) {
+    return 'Antigravity';
+  }
+  if (process.env.CURSOR_AGENT) {
+    return 'Cursor';
+  }
+  if (
+    process.env.CODEX_THREAD_ID ||
+    process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE ||
+    process.env.CODEX_WORKSPACE
+  ) {
+    return 'Codex';
+  }
+  if (process.env.VSCODE_IPC_HOOK || process.env.TERM_PROGRAM === 'vscode') {
+    return 'VS Code';
+  }
+  if (
+    process.env.WARP_SESSION_ID ||
+    process.env.TERM_PROGRAM === 'WarpTerminal' ||
+    process.env.TERM_PROGRAM === 'Warp'
+  ) {
+    return 'Warp';
+  }
+  if (process.env.WINDSURF_AGENT || process.env.WINDSURF_WORKSPACE) {
+    return 'Windsurf';
+  }
+
+  // Claude Desktop doesn't have a known env var.
+  return null;
+}
+
+// Known config paths for different IDEs
+function getConfigPaths() {
+  const platform = process.platform;
+  const home = getUserHomeDir();
+  const currentIDE = detectCurrentIDE();
+  const allPaths = [];
+
+  // Antigravity - dedicated mcp_config.json
+  allPaths.push({
+    name: 'Antigravity',
+    path: path.join(home, '.gemini', 'antigravity', 'mcp_config.json'),
+    format: 'json',
+    canCreate: true,
+  });
+
+  // Codex - dedicated config.toml
+  allPaths.push({
+    name: 'Codex',
+    path: path.join(home, '.codex', 'config.toml'),
+    format: 'toml',
+    canCreate: true,
+  });
+
+  // Claude Desktop - dedicated config file
+  if (platform === 'darwin') {
+    allPaths.push({
+      name: 'Claude Desktop',
+      path: path.join(
+        home,
+        'Library',
+        'Application Support',
+        'Claude',
+        'claude_desktop_config.json'
+      ),
+      format: 'json',
+      canCreate: false,
+    });
+  } else if (platform === 'win32') {
+    allPaths.push({
+      name: 'Claude Desktop',
+      path: path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json'),
+      format: 'json',
+      canCreate: false,
+    });
+  }
+
+  // Cursor - settings.json with mcpServers key
+  if (platform === 'darwin') {
+    allPaths.push({
+      name: 'Cursor',
+      path: path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json'),
+      format: 'json',
+      canCreate: false,
+    });
+  } else if (platform === 'win32') {
+    allPaths.push({
+      name: 'Cursor',
+      path: path.join(process.env.APPDATA || '', 'Cursor', 'User', 'settings.json'),
+      format: 'json',
+      canCreate: false,
+    });
+  } else {
+    allPaths.push({
+      name: 'Cursor',
+      path: path.join(home, '.config', 'Cursor', 'User', 'settings.json'),
+      format: 'json',
+      canCreate: false,
+    });
+  }
+
+  // Cursor global MCP config (discovered by VS Code MCP Discovery)
+  allPaths.push({
+    name: 'Cursor Global',
+    path: path.join(home, '.cursor', 'mcp.json'),
+    format: 'json',
+    canCreate: false,
+    preferredContainerKey: 'mcpServers',
+  });
+
+  // Windsurf global MCP config (discovered by VS Code MCP Discovery)
+  allPaths.push({
+    name: 'Windsurf',
+    path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+    format: 'json',
+    canCreate: false,
+    preferredContainerKey: 'mcpServers',
+  });
+
+  // Warp MCP config
+  allPaths.push({
+    name: 'Warp',
+    path: path.join(home, '.warp', 'mcp_settings.json'),
+    format: 'json',
+    canCreate: true,
+    preferredContainerKey: 'mcpServers',
+  });
+  if (platform === 'win32') {
+    allPaths.push({
+      name: 'Warp AppData',
+      path: path.join(process.env.APPDATA || '', 'Warp', 'mcp_settings.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'mcpServers',
+    });
+  }
+  
+  // VS Code MCP registry (mcp.json uses "servers" key)
+  if (platform === 'darwin') {
+    allPaths.push({
+      name: 'VS Code',
+      path: path.join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+    allPaths.push({
+      name: 'VS Code Insiders',
+      path: path.join(
+        home,
+        'Library',
+        'Application Support',
+        'Code - Insiders',
+        'User',
+        'mcp.json'
+      ),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+  } else if (platform === 'win32') {
+    allPaths.push({
+      name: 'VS Code',
+      path: path.join(process.env.APPDATA || '', 'Code', 'User', 'mcp.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+    allPaths.push({
+      name: 'VS Code Insiders',
+      path: path.join(process.env.APPDATA || '', 'Code - Insiders', 'User', 'mcp.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+  } else {
+    allPaths.push({
+      name: 'VS Code',
+      path: path.join(home, '.config', 'Code', 'User', 'mcp.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+    allPaths.push({
+      name: 'VS Code Insiders',
+      path: path.join(home, '.config', 'Code - Insiders', 'User', 'mcp.json'),
+      format: 'json',
+      canCreate: false,
+      preferredContainerKey: 'servers',
+    });
+  }
+
+  // Keep updates broad so a single install can refresh dedicated configs (Codex + Antigravity)
+  // while still avoiding creation of shared IDE settings files unless they already exist.
+  return allPaths.map((entry) => ({
+    ...entry,
+    canCreate: entry.canCreate || entry.name === currentIDE,
+  }));
+}
+
+// Helper to force output to terminal, bypassing npm's silence
+function forceLog(message) {
+  try {
+    if (process.platform !== 'win32') {
+      writeFileSync('/dev/tty', message + '\n');
+    } else {
+      console.error(message);
+    }
+  } catch (_e) {
+    console.error(message);
+  }
+}
+
+function normalizeIdeName(name) {
+  return String(name || '')
+    .toLowerCase()
+    .replace(/["']/g, '')
+    .replace(/[\s_-]+/g, '');
+}
+
+function ideMatchesFilter(name, filter) {
+  if (!filter) return true;
+  const normalizedName = normalizeIdeName(name);
+  const normalizedFilter = normalizeIdeName(filter);
+  if (!normalizedFilter) return true;
+
+  if (normalizedName === normalizedFilter) return true;
+  if (normalizedFilter === 'claude') return normalizedName === 'claudedesktop';
+  if (normalizedFilter === 'cursor') {
+    return normalizedName === 'cursor' || normalizedName === 'cursorglobal';
+  }
+  if (normalizedFilter === 'windsurf') {
+    return normalizedName === 'windsurf';
+  }
+  if (normalizedFilter === 'warp') {
+    return normalizedName === 'warp' || normalizedName === 'warpappdata';
+  }
+  if (normalizedFilter === 'vscode') {
+    return normalizedName === 'vscode' || normalizedName === 'vscodeinsiders';
+  }
+
+  return false;
+}
+
+export async function register(filter = null) {
+  const binaryPath = process.execPath; // The node binary
+  const scriptPath = fileURLToPath(new URL('../index.js', import.meta.url)); // Absolute path to index.js
+  const currentIDE = detectCurrentIDE();
+
+  // Build args array - add --expose-gc if enableExplicitGc is likely needed
+  // For workspace selection, rely on runtime auto-detection (env vars + cwd) so one config
+  // can be reused across projects without editing the installed path each day.
+  const args = ['--expose-gc', scriptPath];
+
+  const serverConfig = {
+    command: binaryPath,
+    args,
+    disabled: false,
+  };
+
+  const configPaths = getConfigPaths();
+  let registeredCount = 0;
+
+  forceLog(`[Auto-Register] Detecting IDE configurations...`);
+
+  for (const { name, path: configPath, canCreate, format, preferredContainerKey } of configPaths) {
+    if (!ideMatchesFilter(name, filter)) {
+      continue;
+    }
+
+    try {
+      // Check if file exists - create if canCreate is true for this IDE
+      let fileExists = true;
+
+      try {
+        await fs.access(configPath);
+      } catch {
+        fileExists = false;
+
+        // Only create config if this IDE allows it (has dedicated MCP config file)
+        if (canCreate) {
+          try {
+            await fs.mkdir(path.dirname(configPath), { recursive: true });
+            forceLog(`[Auto-Register] Creating ${name} config at ${configPath}`);
+          } catch (mkdirErr) {
+            forceLog(
+              `[Auto-Register] Skipped ${name}: Cannot create config directory: ${mkdirErr.message}`
+            );
+            continue;
+          }
+        } else {
+          // Skip IDEs that use shared settings files if they don't exist
+          continue;
+        }
+      }
+
+      let content = '';
+      if (fileExists) {
+        content = await fs.readFile(configPath, 'utf-8');
+        if (format === 'json' && content.trim()) {
+          const parsed = parseJsonc(content);
+          if (!parsed) {
+            forceLog(
+              `[Auto-Register] Warning: ${name} config is not valid JSON/JSONC; skipping to avoid data loss.`
+            );
+            continue;
+          }
+        }
+      }
+
+      const updated =
+        format === 'toml'
+          ? upsertMcpServerEntryInToml(content, 'heuristic-mcp', serverConfig)
+          : upsertMcpServerEntryInText(
+              content,
+              'heuristic-mcp',
+              serverConfig,
+              preferredContainerKey || 'mcpServers'
+            );
+      if (!updated) {
+        forceLog(
+          `[Auto-Register] Warning: Failed to update ${name} config (could not locate root object).`
+        );
+        continue;
+      }
+
+      // Write back synchronously to avoid race conditions
+      writeFileSync(configPath, updated);
+
+      forceLog(`\x1b[32m[Auto-Register] ✅ Successfully registered with ${name}\x1b[0m`);
+      registeredCount++;
+    } catch (err) {
+      forceLog(`[Auto-Register] Failed to register with ${name}: ${err.message}`);
+    }
+  }
+
+  if (registeredCount === 0) {
+    forceLog(`[Auto-Register] No compatible IDE configurations found to update.`);
+    forceLog(
+      `[Auto-Register] Manual Config:\n${JSON.stringify({ mcpServers: { 'heuristic-mcp': serverConfig } }, null, 2)}`
+    );
+  } else {
+    // Friendly Banner (Using forceLog to bypass npm stdout suppression)
+    forceLog('\n\x1b[36m' + '='.repeat(60));
+    forceLog('   🚀 Heuristic MCP Installed & Configured!   ');
+    forceLog('='.repeat(60) + '\x1b[0m');
+
+    // Show important paths
+    const home = getUserHomeDir();
+    const cacheRoot =
+      process.platform === 'win32'
+        ? path.join(
+            process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'),
+            'heuristic-mcp'
+          )
+        : process.platform === 'darwin'
+          ? path.join(home, 'Library', 'Caches', 'heuristic-mcp')
+          : path.join(process.env.XDG_CACHE_HOME || path.join(home, '.cache'), 'heuristic-mcp');
+
+    forceLog(`
+\x1b[33mACTION REQUIRED:\x1b[0m
+1. \x1b[1mRestart your IDE\x1b[0m (or reload the window) to load the new config.
+2. The server will start automatically in the background.
+
+\x1b[32mSTATUS:\x1b[0m
+- \x1b[1mConfig:\x1b[0m Updated ${registeredCount} config file(s).
+- \x1b[1mIndexing:\x1b[0m Will begin immediately after restart.
+- \x1b[1mUsage:\x1b[0m You can work while it indexes (it catches up!).
+
+\x1b[90mPATHS:\x1b[0m
+- \x1b[1mMCP Config:\x1b[0m ${configPaths.map((p) => p.path).join(', ')}
+- \x1b[1mCache:\x1b[0m ${cacheRoot}
+- \x1b[1mCheck status:\x1b[0m heuristic-mcp --status
+- \x1b[1mView logs:\x1b[0m heuristic-mcp --logs
+
+\x1b[36mHappy Coding! 🤖\x1b[0m
+    `);
+    forceLog(`\n\x1b[90m(Please wait while npm finalizes the installation...)\x1b[0m`);
+  }
+
+  if (currentIDE === 'Warp' && registeredCount === 0) {
+    forceLog(
+      '[Auto-Register] Warp detected but no local Warp MCP config was writable. Use Warp MCP settings/UI if needed.'
+    );
+  }
+}