@nerviq/cli 1.0.0 → 1.2.0

package/src/cursor/domain-packs.js

@@ -8,7 +8,9 @@
  * - .cursor/automations/ (event-driven triggers)
  */
 
-const CURSOR_DOMAIN_PACKS = [
+const { buildAdditionalDomainPacks, detectAdditionalDomainPacks } = require('../domain-pack-expansion');
+
+const BASE_CURSOR_DOMAIN_PACKS = [
   {
     key: 'baseline-general',
     label: 'Baseline General',
@@ -171,6 +173,13 @@ const CURSOR_DOMAIN_PACKS = [
   },
 ];
 
+const CURSOR_DOMAIN_PACKS = [
+  ...BASE_CURSOR_DOMAIN_PACKS,
+  ...buildAdditionalDomainPacks('cursor', {
+    existingKeys: new Set(BASE_CURSOR_DOMAIN_PACKS.map((pack) => pack.key)),
+  }),
+];
+
 function uniqueByKey(items) {
   const seen = new Set();
   const result = [];
@@ -328,6 +337,19 @@ function detectCursorDomainPacks(ctx, stacks = [], assets = {}) {
     addMatch('security-focused', ['Detected security-focused repo signals.', ctx.fileContent('SECURITY.md') ? 'SECURITY.md present.' : null]);
   }
 
+  detectAdditionalDomainPacks({
+    ctx,
+    pkg,
+    deps,
+    stackKeys,
+    addMatch,
+    hasBackend,
+    hasFrontend,
+    hasInfra,
+    hasCi,
+    isEnterpriseGoverned,
+  });
+
   if (matches.length === 0) {
     addMatch('baseline-general', [
       'No stronger platform-specific domain dominated, so a safe general Cursor baseline is the best starting point.',

package/src/cursor/mcp-packs.js

@@ -385,6 +385,237 @@ const CURSOR_MCP_PACKS = [
     excludeTools: [],
     backgroundAgentCompatible: true,
   },
+  // ── 23 new packs ─────────────────────────────────────────────────────────
+  {
+    key: 'supabase-mcp', label: 'Supabase',
+    description: 'Database, auth, and storage access for Supabase projects.',
+    useWhen: 'Repos using Supabase for database, auth, or storage.',
+    adoption: 'Recommended for full-stack Supabase repos. Requires SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY'],
+    serverName: 'supabase',
+    jsonProjection: { command: 'npx', args: ['-y', '@supabase/mcp-server-supabase@latest'], env: { SUPABASE_URL: '${env:SUPABASE_URL}', SUPABASE_SERVICE_ROLE_KEY: '${env:SUPABASE_SERVICE_ROLE_KEY}' } },
+    excludeTools: ['delete_project', 'drop_table'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'prisma-mcp', label: 'Prisma ORM',
+    description: 'Schema inspection and migration management for Prisma.',
+    useWhen: 'Repos using Prisma for database schema and migrations.',
+    adoption: 'Recommended for any repo with a Prisma schema. Requires DATABASE_URL.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['DATABASE_URL'],
+    serverName: 'prisma',
+    jsonProjection: { command: 'npx', args: ['-y', 'prisma-mcp-server@latest'], env: { DATABASE_URL: '${env:DATABASE_URL}' } },
+    excludeTools: ['drop_database'], backgroundAgentCompatible: false,
+  },
+  {
+    key: 'vercel-mcp', label: 'Vercel',
+    description: 'Deployment management and log access for Vercel projects.',
+    useWhen: 'Repos deployed on Vercel.',
+    adoption: 'Recommended for Vercel-hosted repos. Requires VERCEL_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['VERCEL_TOKEN'],
+    serverName: 'vercel',
+    jsonProjection: { command: 'npx', args: ['-y', '@vercel/mcp-server@latest'], env: { VERCEL_TOKEN: '${env:VERCEL_TOKEN}' } },
+    excludeTools: ['delete_project', 'delete_deployment'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'cloudflare-mcp', label: 'Cloudflare',
+    description: 'Workers, KV, R2, and D1 management.',
+    useWhen: 'Repos using Cloudflare Workers, KV, R2, or D1.',
+    adoption: 'Recommended for edge-compute repos. Requires CLOUDFLARE_API_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['CLOUDFLARE_API_TOKEN'],
+    serverName: 'cloudflare',
+    jsonProjection: { command: 'npx', args: ['-y', '@cloudflare/mcp-server-cloudflare@latest'], env: { CLOUDFLARE_API_TOKEN: '${env:CLOUDFLARE_API_TOKEN}' } },
+    excludeTools: ['delete_worker', 'purge_cache'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'aws-mcp', label: 'AWS',
+    description: 'S3, Lambda, DynamoDB, and CloudFormation access.',
+    useWhen: 'Repos using AWS cloud services.',
+    adoption: 'Recommended for cloud-infra repos. Requires AWS credentials.',
+    trustLevel: 'low', transport: 'stdio', requiredAuth: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION'],
+    serverName: 'aws',
+    jsonProjection: { command: 'npx', args: ['-y', '@aws-samples/mcp-server-aws@latest'], env: { AWS_ACCESS_KEY_ID: '${env:AWS_ACCESS_KEY_ID}', AWS_SECRET_ACCESS_KEY: '${env:AWS_SECRET_ACCESS_KEY}', AWS_REGION: '${env:AWS_REGION}' } },
+    excludeTools: ['delete_stack', 'terminate_instances', 'delete_bucket'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'redis-mcp', label: 'Redis',
+    description: 'Cache and session management via Redis.',
+    useWhen: 'Repos using Redis for caching or sessions.',
+    adoption: 'Recommended for performance-critical repos. Requires REDIS_URL.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['REDIS_URL'],
+    serverName: 'redis',
+    jsonProjection: { command: 'npx', args: ['-y', 'redis-mcp-server@latest'], env: { REDIS_URL: '${env:REDIS_URL}' } },
+    excludeTools: ['flushall', 'flushdb'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'mongodb-mcp', label: 'MongoDB',
+    description: 'Document database access for MongoDB.',
+    useWhen: 'Repos using MongoDB.',
+    adoption: 'Recommended for document-model repos. Requires MONGODB_URI.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['MONGODB_URI'],
+    serverName: 'mongodb',
+    jsonProjection: { command: 'npx', args: ['-y', '@mongodb-js/mongodb-mcp-server@latest'], env: { MONGODB_URI: '${env:MONGODB_URI}' } },
+    excludeTools: ['drop_collection', 'drop_database'], backgroundAgentCompatible: false,
+  },
+  {
+    key: 'twilio-mcp', label: 'Twilio',
+    description: 'SMS, voice, and messaging via Twilio.',
+    useWhen: 'Repos using Twilio for communications.',
+    adoption: 'Recommended for communication-feature repos. Requires TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN.',
+    trustLevel: 'low', transport: 'stdio', requiredAuth: ['TWILIO_ACCOUNT_SID', 'TWILIO_AUTH_TOKEN'],
+    serverName: 'twilio',
+    jsonProjection: { command: 'npx', args: ['-y', 'twilio-mcp-server@latest'], env: { TWILIO_ACCOUNT_SID: '${env:TWILIO_ACCOUNT_SID}', TWILIO_AUTH_TOKEN: '${env:TWILIO_AUTH_TOKEN}' } },
+    excludeTools: ['delete_message'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'sendgrid-mcp', label: 'SendGrid',
+    description: 'Transactional and marketing email via SendGrid.',
+    useWhen: 'Repos using SendGrid for email delivery.',
+    adoption: 'Recommended for repos with email workflows. Requires SENDGRID_API_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['SENDGRID_API_KEY'],
+    serverName: 'sendgrid',
+    jsonProjection: { command: 'npx', args: ['-y', 'sendgrid-mcp-server@latest'], env: { SENDGRID_API_KEY: '${env:SENDGRID_API_KEY}' } },
+    excludeTools: [], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'algolia-mcp', label: 'Algolia Search',
+    description: 'Search indexing and query management via Algolia.',
+    useWhen: 'Repos using Algolia for search.',
+    adoption: 'Recommended for content-heavy and e-commerce repos. Requires ALGOLIA_APP_ID and ALGOLIA_API_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['ALGOLIA_APP_ID', 'ALGOLIA_API_KEY'],
+    serverName: 'algolia',
+    jsonProjection: { command: 'npx', args: ['-y', 'algolia-mcp-server@latest'], env: { ALGOLIA_APP_ID: '${env:ALGOLIA_APP_ID}', ALGOLIA_API_KEY: '${env:ALGOLIA_API_KEY}' } },
+    excludeTools: ['delete_index'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'planetscale-mcp', label: 'PlanetScale',
+    description: 'MySQL database management via PlanetScale.',
+    useWhen: 'Repos using PlanetScale for serverless MySQL.',
+    adoption: 'Recommended for MySQL-based repos on PlanetScale. Requires PLANETSCALE_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['PLANETSCALE_TOKEN'],
+    serverName: 'planetscale',
+    jsonProjection: { command: 'npx', args: ['-y', 'planetscale-mcp-server@latest'], env: { PLANETSCALE_TOKEN: '${env:PLANETSCALE_TOKEN}' } },
+    excludeTools: ['delete_database'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'neon-mcp', label: 'Neon Serverless Postgres',
+    description: 'Serverless PostgreSQL management via Neon.',
+    useWhen: 'Repos using Neon for serverless Postgres.',
+    adoption: 'Recommended for serverless and edge Postgres repos. Requires NEON_API_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['NEON_API_KEY'],
+    serverName: 'neon',
+    jsonProjection: { command: 'npx', args: ['-y', '@neondatabase/mcp-server-neon@latest'], env: { NEON_API_KEY: '${env:NEON_API_KEY}' } },
+    excludeTools: ['delete_project'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'turso-mcp', label: 'Turso Edge SQLite',
+    description: 'Distributed edge SQLite management via Turso.',
+    useWhen: 'Repos using Turso for edge SQLite.',
+    adoption: 'Recommended for edge and multi-region apps. Requires TURSO_DATABASE_URL and TURSO_AUTH_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['TURSO_DATABASE_URL', 'TURSO_AUTH_TOKEN'],
+    serverName: 'turso',
+    jsonProjection: { command: 'npx', args: ['-y', 'turso-mcp-server@latest'], env: { TURSO_DATABASE_URL: '${env:TURSO_DATABASE_URL}', TURSO_AUTH_TOKEN: '${env:TURSO_AUTH_TOKEN}' } },
+    excludeTools: ['destroy_database'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'upstash-mcp', label: 'Upstash (Redis + Kafka)',
+    description: 'Serverless Redis, Kafka, and QStash via Upstash.',
+    useWhen: 'Repos using Upstash for serverless caching or messaging.',
+    adoption: 'Recommended for serverless apps. Requires UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['UPSTASH_REDIS_REST_URL', 'UPSTASH_REDIS_REST_TOKEN'],
+    serverName: 'upstash',
+    jsonProjection: { command: 'npx', args: ['-y', '@upstash/mcp-server@latest'], env: { UPSTASH_REDIS_REST_URL: '${env:UPSTASH_REDIS_REST_URL}', UPSTASH_REDIS_REST_TOKEN: '${env:UPSTASH_REDIS_REST_TOKEN}' } },
+    excludeTools: [], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'convex-mcp', label: 'Convex',
+    description: 'Reactive backend-as-a-service management via Convex.',
+    useWhen: 'Repos using Convex as reactive backend.',
+    adoption: 'Recommended for real-time full-stack repos. Requires CONVEX_DEPLOYMENT.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['CONVEX_DEPLOYMENT'],
+    serverName: 'convex',
+    jsonProjection: { command: 'npx', args: ['-y', '@convex-dev/mcp-server@latest'], env: { CONVEX_DEPLOYMENT: '${env:CONVEX_DEPLOYMENT}' } },
+    excludeTools: ['delete_deployment'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'clerk-mcp', label: 'Clerk Authentication',
+    description: 'User auth and session management via Clerk.',
+    useWhen: 'Repos using Clerk for authentication.',
+    adoption: 'Recommended for SaaS repos with Clerk. Requires CLERK_SECRET_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['CLERK_SECRET_KEY'],
+    serverName: 'clerk',
+    jsonProjection: { command: 'npx', args: ['-y', '@clerk/mcp-server@latest'], env: { CLERK_SECRET_KEY: '${env:CLERK_SECRET_KEY}' } },
+    excludeTools: ['delete_user'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'resend-mcp', label: 'Resend Email',
+    description: 'Developer-focused transactional email via Resend.',
+    useWhen: 'Repos using Resend for email.',
+    adoption: 'Recommended for modern full-stack repos. Requires RESEND_API_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['RESEND_API_KEY'],
+    serverName: 'resend',
+    jsonProjection: { command: 'npx', args: ['-y', 'resend-mcp-server@latest'], env: { RESEND_API_KEY: '${env:RESEND_API_KEY}' } },
+    excludeTools: [], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'temporal-mcp', label: 'Temporal Workflow',
+    description: 'Durable workflow orchestration via Temporal.',
+    useWhen: 'Repos using Temporal for workflows.',
+    adoption: 'Recommended for async-workflow and microservice repos. Requires TEMPORAL_ADDRESS.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['TEMPORAL_ADDRESS'],
+    serverName: 'temporal',
+    jsonProjection: { command: 'npx', args: ['-y', 'temporal-mcp-server@latest'], env: { TEMPORAL_ADDRESS: '${env:TEMPORAL_ADDRESS}' } },
+    excludeTools: ['terminate_workflow'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'launchdarkly-mcp', label: 'LaunchDarkly',
+    description: 'Feature flags and experimentation via LaunchDarkly.',
+    useWhen: 'Repos using LaunchDarkly for feature flags.',
+    adoption: 'Recommended for feature-flag-driven development. Requires LAUNCHDARKLY_ACCESS_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['LAUNCHDARKLY_ACCESS_TOKEN'],
+    serverName: 'launchdarkly',
+    jsonProjection: { command: 'npx', args: ['-y', 'launchdarkly-mcp-server@latest'], env: { LAUNCHDARKLY_ACCESS_TOKEN: '${env:LAUNCHDARKLY_ACCESS_TOKEN}' } },
+    excludeTools: ['delete_flag'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'datadog-mcp', label: 'Datadog',
+    description: 'Monitoring, APM, and log management via Datadog.',
+    useWhen: 'Repos using Datadog for observability.',
+    adoption: 'Recommended for production repos. Requires DATADOG_API_KEY and DATADOG_APP_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['DATADOG_API_KEY', 'DATADOG_APP_KEY'],
+    serverName: 'datadog',
+    jsonProjection: { command: 'npx', args: ['-y', '@datadog/mcp-server@latest'], env: { DATADOG_API_KEY: '${env:DATADOG_API_KEY}', DATADOG_APP_KEY: '${env:DATADOG_APP_KEY}' } },
+    excludeTools: ['delete_monitor'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'grafana-mcp', label: 'Grafana',
+    description: 'Dashboard and observability access via Grafana.',
+    useWhen: 'Repos using Grafana for dashboards.',
+    adoption: 'Recommended for observability-focused repos. Requires GRAFANA_URL and GRAFANA_API_KEY.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['GRAFANA_URL', 'GRAFANA_API_KEY'],
+    serverName: 'grafana',
+    jsonProjection: { command: 'npx', args: ['-y', 'grafana-mcp-server@latest'], env: { GRAFANA_URL: '${env:GRAFANA_URL}', GRAFANA_API_KEY: '${env:GRAFANA_API_KEY}' } },
+    excludeTools: ['delete_dashboard'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'circleci-mcp', label: 'CircleCI',
+    description: 'CI/CD pipeline access via CircleCI.',
+    useWhen: 'Repos using CircleCI for CI/CD.',
+    adoption: 'Recommended for CircleCI-powered projects. Requires CIRCLECI_TOKEN.',
+    trustLevel: 'medium', transport: 'stdio', requiredAuth: ['CIRCLECI_TOKEN'],
+    serverName: 'circleci',
+    jsonProjection: { command: 'npx', args: ['-y', 'circleci-mcp-server@latest'], env: { CIRCLECI_TOKEN: '${env:CIRCLECI_TOKEN}' } },
+    excludeTools: ['cancel_pipeline'], backgroundAgentCompatible: true,
+  },
+  {
+    key: 'anthropic-mcp', label: 'Anthropic Claude API',
+    description: 'Claude API access for AI-powered apps.',
+    useWhen: 'Repos building on the Anthropic Claude API.',
+    adoption: 'Recommended for AI-powered apps using Claude. Requires ANTHROPIC_API_KEY.',
+    trustLevel: 'high', transport: 'stdio', requiredAuth: ['ANTHROPIC_API_KEY'],
+    serverName: 'anthropic',
+    jsonProjection: { command: 'npx', args: ['-y', '@anthropic-ai/mcp-server@latest'], env: { ANTHROPIC_API_KEY: '${env:ANTHROPIC_API_KEY}' } },
+    excludeTools: [], backgroundAgentCompatible: true,
+  },
 ];
 
 // --- Helpers ---
@@ -489,6 +720,32 @@ function recommendCursorMcpPacks(stacks = [], domainPacks = [], options = {}) {
   if (domainKeys.has('ecommerce') && (hasDependency(deps, 'shopify') || hasDependency(deps, '@shopify/shopify-api'))) recommended.add('shopify-mcp');
   if (domainKeys.has('ai-ml')) recommended.add('huggingface-mcp');
   if (domainKeys.has('design-system')) recommended.add('figma-mcp');
+  // ── 23 new packs recommendation logic ────────────────────────────────────
+  if (ctx) {
+    if (hasDependency(deps, '@supabase/supabase-js') || hasDependency(deps, '@supabase/auth-helpers-nextjs') || hasFileContentMatch(ctx, '.env', /SUPABASE/i) || hasFileContentMatch(ctx, '.env.example', /SUPABASE/i)) recommended.add('supabase-mcp');
+    if (hasFileContentMatch(ctx, 'schema.prisma', /\S/) || hasDependency(deps, '@prisma/client') || hasDependency(deps, 'prisma')) recommended.add('prisma-mcp');
+    if (ctx.files.includes('vercel.json') || hasFileContentMatch(ctx, 'package.json', /"deploy":\s*"vercel/i) || hasFileContentMatch(ctx, '.env', /VERCEL_TOKEN/i)) recommended.add('vercel-mcp');
+    if (hasFileContentMatch(ctx, 'wrangler.toml', /\S/) || hasDependency(deps, 'wrangler') || hasFileContentMatch(ctx, '.env', /CLOUDFLARE/i)) recommended.add('cloudflare-mcp');
+    if (hasFileContentMatch(ctx, '.env', /AWS_ACCESS_KEY/i) || ctx.files.some(f => /serverless\.yml|template\.ya?ml|cdk\.json/.test(f))) recommended.add('aws-mcp');
+    if (hasDependency(deps, 'redis') || hasDependency(deps, 'ioredis') || hasDependency(deps, '@redis/client') || hasFileContentMatch(ctx, '.env', /REDIS_URL/i)) recommended.add('redis-mcp');
+    if (hasDependency(deps, 'mongoose') || hasDependency(deps, 'mongodb') || hasFileContentMatch(ctx, '.env', /MONGODB_URI/i)) recommended.add('mongodb-mcp');
+    if (hasDependency(deps, 'twilio') || hasFileContentMatch(ctx, '.env', /TWILIO_/i)) recommended.add('twilio-mcp');
+    if (hasDependency(deps, '@sendgrid/mail') || hasFileContentMatch(ctx, '.env', /SENDGRID_API_KEY/i)) recommended.add('sendgrid-mcp');
+    if (hasDependency(deps, 'algoliasearch') || hasDependency(deps, '@algolia/client-search') || hasFileContentMatch(ctx, '.env', /ALGOLIA_/i)) recommended.add('algolia-mcp');
+    if (hasFileContentMatch(ctx, '.env', /PLANETSCALE_TOKEN/i)) recommended.add('planetscale-mcp');
+    if (hasDependency(deps, '@neondatabase/serverless') || hasFileContentMatch(ctx, '.env', /NEON_/i)) recommended.add('neon-mcp');
+    if (hasDependency(deps, '@libsql/client') || hasFileContentMatch(ctx, '.env', /TURSO_/i)) recommended.add('turso-mcp');
+    if (hasDependency(deps, '@upstash/redis') || hasDependency(deps, '@upstash/kafka') || hasFileContentMatch(ctx, '.env', /UPSTASH_/i)) recommended.add('upstash-mcp');
+    if (hasDependency(deps, 'convex') || hasFileContentMatch(ctx, 'convex.json', /\S/) || hasFileContentMatch(ctx, '.env', /CONVEX_/i)) recommended.add('convex-mcp');
+    if (hasDependency(deps, '@clerk/nextjs') || hasDependency(deps, '@clerk/backend') || hasFileContentMatch(ctx, '.env', /CLERK_/i)) recommended.add('clerk-mcp');
+    if (hasDependency(deps, 'resend') || hasFileContentMatch(ctx, '.env', /RESEND_API_KEY/i)) recommended.add('resend-mcp');
+    if (hasDependency(deps, '@temporalio/client') || hasFileContentMatch(ctx, '.env', /TEMPORAL_/i)) recommended.add('temporal-mcp');
+    if (hasDependency(deps, '@launchdarkly/node-server-sdk') || hasFileContentMatch(ctx, '.env', /LAUNCHDARKLY_/i)) recommended.add('launchdarkly-mcp');
+    if (hasDependency(deps, 'dd-trace') || hasFileContentMatch(ctx, '.env', /DATADOG_/i)) recommended.add('datadog-mcp');
+    if (hasFileContentMatch(ctx, 'docker-compose.yml', /grafana/i) || hasFileContentMatch(ctx, '.env', /GRAFANA_/i)) recommended.add('grafana-mcp');
+    if (ctx.files.some(f => /\.circleci\/config/.test(f)) || hasFileContentMatch(ctx, '.env', /CIRCLECI_/i)) recommended.add('circleci-mcp');
+    if (hasDependency(deps, '@anthropic-ai/sdk') || hasDependency(deps, 'anthropic') || hasFileContentMatch(ctx, '.env', /ANTHROPIC_API_KEY/i)) recommended.add('anthropic-mcp');
+  }
   if (recommended.size >= 2) recommended.add('mcp-security');
   if (recommended.size === 0) recommended.add('context7-docs');