domain-search-mcp 1.2.7 → 1.2.8

package/README.md

@@ -4424,6 +4424,485 @@ async function domainResearchPipeline(businessIdea: string) {
 const research = await domainResearchPipeline("ai-powered code review tool");
 ```
 
+#### Startup-Type Optimized Parameters
+
+Different startup types require different tool parameter configurations for optimal results:
+
+```typescript
+// Startup type definitions with optimized tool parameters
+const STARTUP_TYPE_CONFIGS = {
+  tech: {
+    // Tech startups: developer tools, SaaS, APIs
+    tlds: ["io", "dev", "app", "com", "sh"],
+    suggestStyle: "brandable" as const,
+    socialPlatforms: ["github", "twitter", "npm", "pypi", "producthunt"],
+    priceThreshold: 50,  // Tech startups accept higher TLD costs
+    industryHint: "tech" as const
+  },
+  ecommerce: {
+    // E-commerce: retail, marketplace, DTC brands
+    tlds: ["com", "co", "shop", "store", "io"],
+    suggestStyle: "brandable" as const,
+    socialPlatforms: ["instagram", "twitter", "tiktok", "pinterest"],
+    priceThreshold: 25,  // Lower threshold, .com preferred
+    industryHint: "ecommerce" as const
+  },
+  creative: {
+    // Creative agencies: design, media, content
+    tlds: ["design", "studio", "io", "co", "com"],
+    suggestStyle: "creative" as const,
+    socialPlatforms: ["instagram", "twitter", "dribbble", "behance"],
+    priceThreshold: 35,
+    industryHint: "creative" as const
+  },
+  fintech: {
+    // Financial technology: payments, banking, crypto
+    tlds: ["com", "io", "finance", "money", "app"],
+    suggestStyle: "brandable" as const,
+    socialPlatforms: ["twitter", "linkedin", "github"],
+    priceThreshold: 100,  // Premium domains acceptable
+    industryHint: "finance" as const
+  },
+  healthcare: {
+    // Healthcare & wellness startups
+    tlds: ["health", "care", "com", "io", "app"],
+    suggestStyle: "descriptive" as const,
+    socialPlatforms: ["twitter", "linkedin", "facebook"],
+    priceThreshold: 40,
+    industryHint: "health" as const
+  }
+};
+
+type StartupType = keyof typeof STARTUP_TYPE_CONFIGS;
+```
+
+#### Complete Startup Research Pipeline with Error Recovery
+
+Production-ready pipeline with comprehensive error handling and retry logic:
+
+```typescript
+import {
+  searchDomain,
+  tldInfo,
+  suggestDomainsSmart,
+  checkSocials,
+  compareRegistrars
+} from 'domain-search-mcp';
+
+interface PipelineResult {
+  success: boolean;
+  startupName: string;
+  startupType: StartupType;
+  domains: DomainRecommendation[];
+  socialAnalysis: SocialAnalysis[];
+  tldContext: TldContext[];
+  errors: PipelineError[];
+  executionTime: number;
+}
+
+interface PipelineError {
+  stage: string;
+  error: string;
+  recoverable: boolean;
+  fallbackUsed?: string;
+}
+
+// Retry wrapper with exponential backoff
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: { maxRetries: number; baseDelay: number; stageName: string }
+): Promise<{ result: T | null; error: PipelineError | null }> {
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      const result = await fn();
+      return { result, error: null };
+    } catch (err) {
+      lastError = err as Error;
+
+      if (attempt < options.maxRetries) {
+        const delay = options.baseDelay * Math.pow(2, attempt);
+        console.log(`⚠️ ${options.stageName} failed, retrying in ${delay}ms...`);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+
+  return {
+    result: null,
+    error: {
+      stage: options.stageName,
+      error: lastError?.message || 'Unknown error',
+      recoverable: false
+    }
+  };
+}
+
+async function startupDomainResearchPipeline(
+  startupName: string,
+  startupType: StartupType = 'tech'
+): Promise<PipelineResult> {
+  const startTime = Date.now();
+  const config = STARTUP_TYPE_CONFIGS[startupType];
+  const errors: PipelineError[] = [];
+
+  console.log(`\n🚀 Starting domain research for "${startupName}" (${startupType} startup)`);
+  console.log(`   Preferred TLDs: ${config.tlds.join(', ')}`);
+  console.log(`   Social platforms: ${config.socialPlatforms.join(', ')}`);
+
+  // Stage 1: Get TLD context with error recovery
+  console.log('\n📋 Stage 1: Fetching TLD information...');
+  const tldResults: TldContext[] = [];
+
+  for (const tld of config.tlds) {
+    const { result, error } = await withRetry(
+      () => tldInfo({ tld, detailed: true }),
+      { maxRetries: 2, baseDelay: 1000, stageName: `tld_info(${tld})` }
+    );
+
+    if (result) {
+      tldResults.push({
+        tld: result.tld,
+        description: result.description,
+        priceRange: result.price_range,
+        typicalUse: result.typical_use,
+        restrictions: result.restrictions,
+        recommendation: result.recommendation
+      });
+      console.log(`   ✅ .${tld}: ${result.description.substring(0, 50)}...`);
+    } else if (error) {
+      errors.push(error);
+      console.log(`   ⚠️ .${tld}: Failed to fetch info`);
+    }
+  }
+
+  // Stage 2: Generate smart suggestions with startup context
+  console.log('\n💡 Stage 2: Generating domain suggestions...');
+
+  const { result: suggestions, error: suggestError } = await withRetry(
+    () => suggestDomainsSmart({
+      query: startupName,
+      tld: config.tlds[0],  // Primary TLD
+      style: config.suggestStyle,
+      industry: config.industryHint,
+      max_suggestions: 20,
+      include_premium: config.priceThreshold > 50
+    }),
+    { maxRetries: 2, baseDelay: 1500, stageName: 'suggest_domains_smart' }
+  );
+
+  if (suggestError) {
+    errors.push(suggestError);
+    console.log('   ⚠️ Smart suggestions failed, falling back to basic search');
+  }
+
+  // Stage 3: Check availability across all preferred TLDs
+  console.log('\n🔍 Stage 3: Checking domain availability...');
+
+  const { result: availability, error: searchError } = await withRetry(
+    () => searchDomain({
+      domain_name: startupName,
+      tlds: config.tlds
+    }),
+    { maxRetries: 3, baseDelay: 1000, stageName: 'search_domain' }
+  );
+
+  if (searchError) {
+    errors.push(searchError);
+  }
+
+  // Stage 4: Social media availability with platform-specific handling
+  console.log('\n🌐 Stage 4: Checking social media availability...');
+
+  const { result: socialResults, error: socialError } = await withRetry(
+    () => checkSocials({
+      name: startupName.toLowerCase().replace(/[^a-z0-9]/g, ''),
+      platforms: config.socialPlatforms
+    }),
+    { maxRetries: 2, baseDelay: 2000, stageName: 'check_socials' }
+  );
+
+  // Process social results with confidence levels
+  const socialAnalysis: SocialAnalysis[] = [];
+  if (socialResults) {
+    for (const platform of socialResults.platforms) {
+      socialAnalysis.push({
+        platform: platform.platform,
+        available: platform.available,
+        confidence: platform.confidence || 'unknown',
+        url: platform.profile_url,
+        recommendation: getSocialRecommendation(platform, startupType)
+      });
+
+      const status = platform.available ? '✅' : '❌';
+      const conf = platform.confidence ? ` (${platform.confidence})` : '';
+      console.log(`   ${status} ${platform.platform}${conf}`);
+    }
+  } else if (socialError) {
+    errors.push({
+      ...socialError,
+      fallbackUsed: 'Manual verification recommended'
+    });
+  }
+
+  // Stage 5: Price comparison for available domains
+  console.log('\n💰 Stage 5: Comparing registrar pricing...');
+
+  const domains: DomainRecommendation[] = [];
+  const availableDomains = availability?.results.filter(r => r.available) || [];
+
+  for (const domain of availableDomains.slice(0, 5)) {
+    const domainName = domain.domain.split('.')[0];
+    const tld = domain.domain.split('.').pop()!;
+
+    const { result: pricing } = await withRetry(
+      () => compareRegistrars({ domain: domainName, tld }),
+      { maxRetries: 1, baseDelay: 1000, stageName: `compare_registrars(${domain.domain})` }
+    );
+
+    const tldContext = tldResults.find(t => t.tld === tld);
+
+    domains.push({
+      domain: domain.domain,
+      available: true,
+      priceFirstYear: pricing?.best_first_year?.price || domain.price_first_year,
+      priceRenewal: pricing?.best_renewal?.price,
+      bestRegistrar: pricing?.best_first_year?.registrar || domain.registrar,
+      tldInfo: tldContext,
+      withinBudget: (domain.price_first_year || 0) <= config.priceThreshold,
+      score: calculateDomainScore(domain, tldContext, socialAnalysis, config)
+    });
+
+    console.log(`   ${domain.domain}: $${domain.price_first_year}/yr`);
+  }
+
+  // Sort by score
+  domains.sort((a, b) => (b.score || 0) - (a.score || 0));
+
+  const executionTime = Date.now() - startTime;
+
+  console.log(`\n✨ Research complete in ${executionTime}ms`);
+  console.log(`   ${domains.length} available domains found`);
+  console.log(`   ${errors.length} errors encountered`);
+
+  return {
+    success: errors.length === 0,
+    startupName,
+    startupType,
+    domains,
+    socialAnalysis,
+    tldContext: tldResults,
+    errors,
+    executionTime
+  };
+}
+
+// Helper: Calculate domain score based on multiple factors
+function calculateDomainScore(
+  domain: any,
+  tldContext: TldContext | undefined,
+  social: SocialAnalysis[],
+  config: typeof STARTUP_TYPE_CONFIGS[StartupType]
+): number {
+  let score = 50;  // Base score
+
+  // Price factor (lower is better, up to threshold)
+  const price = domain.price_first_year || 0;
+  if (price <= config.priceThreshold * 0.5) score += 20;
+  else if (price <= config.priceThreshold) score += 10;
+  else score -= 10;
+
+  // TLD preference factor
+  const tldIndex = config.tlds.indexOf(domain.domain.split('.').pop());
+  if (tldIndex === 0) score += 15;  // Primary TLD
+  else if (tldIndex <= 2) score += 10;
+  else if (tldIndex > -1) score += 5;
+
+  // Social availability factor
+  const availableSocials = social.filter(s => s.available).length;
+  score += availableSocials * 5;
+
+  // Length factor (shorter is better)
+  const nameLength = domain.domain.split('.')[0].length;
+  if (nameLength <= 6) score += 10;
+  else if (nameLength <= 10) score += 5;
+  else if (nameLength > 15) score -= 5;
+
+  return Math.max(0, Math.min(100, score));
+}
+
+// Helper: Get platform-specific recommendations
+function getSocialRecommendation(
+  platform: any,
+  startupType: StartupType
+): string {
+  if (platform.available) {
+    return `Register @${platform.name} immediately to secure brand consistency`;
+  }
+
+  const alternatives: Record<string, string> = {
+    twitter: 'Consider @get[name], @[name]app, or @[name]hq',
+    github: 'Use organization account or add suffix like -app, -io',
+    instagram: 'Try [name].official, get[name], or [name]_app',
+    npm: 'Use scoped package @[org]/[name]',
+    linkedin: 'Create company page with full business name'
+  };
+
+  return alternatives[platform.platform] || 'Consider alternative naming';
+}
+
+// Usage with different startup types
+const techStartupReport = await startupDomainResearchPipeline("codeflow", "tech");
+const ecommerceReport = await startupDomainResearchPipeline("shopwave", "ecommerce");
+const creativeReport = await startupDomainResearchPipeline("pixelcraft", "creative");
+```
+
+#### Formatted Report Output by Startup Type
+
+Generate customized reports based on startup category:
+
+```typescript
+function formatStartupReport(result: PipelineResult): string {
+  const { startupName, startupType, domains, socialAnalysis, tldContext, errors } = result;
+
+  let report = `
+╔══════════════════════════════════════════════════════════════╗
+║  DOMAIN RESEARCH REPORT: ${startupName.toUpperCase().padEnd(35)}║
+║  Type: ${startupType.toUpperCase()} STARTUP${' '.repeat(45 - startupType.length)}║
+║  Generated: ${new Date().toISOString().split('T')[0]}${' '.repeat(40)}║
+╚══════════════════════════════════════════════════════════════╝
+`;
+
+  // TLD Analysis Section
+  report += `\n┌─ TLD ANALYSIS ${'─'.repeat(46)}┐\n`;
+  for (const tld of tldContext) {
+    report += `│ .${tld.tld.padEnd(6)} │ ${tld.description.substring(0, 40).padEnd(40)} │\n`;
+    report += `│        │ Price: $${tld.priceRange.min}-$${tld.priceRange.max}/yr`.padEnd(52) + `│\n`;
+  }
+  report += `└${'─'.repeat(60)}┘\n`;
+
+  // Domain Recommendations Section
+  report += `\n┌─ TOP DOMAIN RECOMMENDATIONS ${'─'.repeat(31)}┐\n`;
+  report += `│ Rank │ Domain${' '.repeat(20)}│ Price  │ Score │\n`;
+  report += `├──────┼${'-'.repeat(26)}┼────────┼───────┤\n`;
+
+  domains.slice(0, 5).forEach((d, i) => {
+    const rank = `#${i + 1}`.padEnd(4);
+    const domain = d.domain.padEnd(25);
+    const price = `$${d.priceFirstYear}`.padEnd(6);
+    const score = `${d.score}/100`;
+    report += `│ ${rank} │ ${domain} │ ${price} │ ${score.padEnd(5)} │\n`;
+  });
+  report += `└${'─'.repeat(60)}┘\n`;
+
+  // Social Media Section
+  report += `\n┌─ SOCIAL MEDIA AVAILABILITY ${'─'.repeat(32)}┐\n`;
+  for (const social of socialAnalysis) {
+    const status = social.available ? '✅ Available' : '❌ Taken';
+    const conf = social.confidence !== 'unknown' ? ` (${social.confidence})` : '';
+    report += `│ ${social.platform.padEnd(12)} │ ${status}${conf}`.padEnd(48) + `│\n`;
+    if (!social.available) {
+      report += `│              │ → ${social.recommendation.substring(0, 35)}`.padEnd(48) + `│\n`;
+    }
+  }
+  report += `└${'─'.repeat(60)}┘\n`;
+
+  // Recommendations by startup type
+  report += `\n┌─ ${startupType.toUpperCase()} STARTUP RECOMMENDATIONS ${'─'.repeat(26)}┐\n`;
+
+  const typeRecommendations: Record<StartupType, string[]> = {
+    tech: [
+      '→ Prioritize .io or .dev for developer credibility',
+      '→ Secure GitHub org and npm package name',
+      '→ Consider .sh for CLI tools'
+    ],
+    ecommerce: [
+      '→ .com is essential for consumer trust',
+      '→ Secure Instagram and TikTok handles',
+      '→ Consider .shop or .store as secondary'
+    ],
+    creative: [
+      '→ .design or .studio signals creative focus',
+      '→ Instagram presence is critical',
+      '→ Shorter names work better for branding'
+    ],
+    fintech: [
+      '→ .com required for financial credibility',
+      '→ Avoid hyphens - trust signals matter',
+      '→ LinkedIn company page essential'
+    ],
+    healthcare: [
+      '→ .health TLD builds trust',
+      '→ Avoid playful names - professionalism matters',
+      '→ Verify regulatory compliance for domain use'
+    ]
+  };
+
+  for (const rec of typeRecommendations[startupType]) {
+    report += `│ ${rec.padEnd(58)} │\n`;
+  }
+  report += `└${'─'.repeat(60)}┘\n`;
+
+  // Error summary if any
+  if (errors.length > 0) {
+    report += `\n⚠️ WARNINGS: ${errors.length} issues encountered during research\n`;
+    errors.forEach(e => {
+      report += `   • ${e.stage}: ${e.error}\n`;
+    });
+  }
+
+  return report;
+}
+
+// Generate and print formatted report
+const result = await startupDomainResearchPipeline("nexaflow", "tech");
+console.log(formatStartupReport(result));
+```
+
+**Sample Output:**
+```
+╔══════════════════════════════════════════════════════════════╗
+║  DOMAIN RESEARCH REPORT: NEXAFLOW                            ║
+║  Type: TECH STARTUP                                          ║
+║  Generated: 2024-01-15                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+┌─ TLD ANALYSIS ──────────────────────────────────────────────┐
+│ .io     │ Popular with tech startups and SaaS              │
+│         │ Price: $32-$44/yr                                 │
+│ .dev    │ Google TLD for developers                        │
+│         │ Price: $12-$16/yr                                 │
+│ .app    │ Mobile and web applications                      │
+│         │ Price: $14-$18/yr                                 │
+└──────────────────────────────────────────────────────────────┘
+
+┌─ TOP DOMAIN RECOMMENDATIONS ─────────────────────────────────┐
+│ Rank │ Domain                    │ Price  │ Score │
+├──────┼──────────────────────────┼────────┼───────┤
+│ #1   │ nexaflow.dev              │ $14.95 │ 85/100│
+│ #2   │ nexaflow.io               │ $39.95 │ 78/100│
+│ #3   │ nexaflow.app              │ $14.95 │ 75/100│
+│ #4   │ nexaflow.com              │ $9.95  │ 72/100│
+│ #5   │ nexaflow.sh               │ $24.95 │ 65/100│
+└──────────────────────────────────────────────────────────────┘
+
+┌─ SOCIAL MEDIA AVAILABILITY ──────────────────────────────────┐
+│ github       │ ✅ Available (high)                          │
+│ twitter      │ ❌ Taken (high)                              │
+│              │ → Consider @getnexaflow, @nexaflowapp        │
+│ npm          │ ✅ Available (high)                          │
+│ pypi         │ ✅ Available (high)                          │
+│ producthunt  │ ✅ Available (medium)                        │
+└──────────────────────────────────────────────────────────────┘
+
+┌─ TECH STARTUP RECOMMENDATIONS ───────────────────────────────┐
+│ → Prioritize .io or .dev for developer credibility           │
+│ → Secure GitHub org and npm package name                     │
+│ → Consider .sh for CLI tools                                 │
+└──────────────────────────────────────────────────────────────┘
+```
+
 ## Security
 
 - API keys are never logged (automatic secret masking)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domain-search-mcp",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Fast domain availability aggregator MCP server. Check availability across Porkbun, Namecheap, RDAP, and WHOIS. Compare pricing. Get suggestions.",
   "main": "dist/server.js",
   "types": "dist/server.d.ts",