domsniper 0.1.2 → 0.2.0

package/src/core/features/domain-suggest.ts

@@ -1,3 +1,5 @@
+import { scoreDomain } from "./scoring.js";
+
 const PREFIXES = [
   "get", "try", "use", "go", "my", "hey", "the",
   "super", "hyper", "ultra", "mega", "meta", "neo",
@@ -85,3 +87,42 @@ export function generateSuggestions(
 
   return suggestions.slice(0, maxResults);
 }
+
+export interface ScoredSuggestion extends Suggestion {
+  score: number;
+  grade: string;
+}
+
+/**
+ * Generate suggestions across multiple TLDs, scored and sorted by quality
+ */
+export function generateScoredSuggestions(
+  keyword: string,
+  tlds: string[] = ["com", "io", "dev", "app", "co"],
+  maxResults: number = 30
+): ScoredSuggestion[] {
+  const word = keyword.toLowerCase().replace(/[^a-z0-9]/g, "");
+  if (!word) return [];
+
+  const all: ScoredSuggestion[] = [];
+  const seen = new Set<string>();
+
+  for (const tld of tlds) {
+    const suggestions = generateSuggestions(word, tld, 50);
+    for (const s of suggestions) {
+      if (seen.has(s.domain)) continue;
+      seen.add(s.domain);
+      const score = scoreDomain(s.domain);
+      all.push({
+        ...s,
+        score: score.total,
+        grade: score.total >= 85 ? "A+" : score.total >= 75 ? "A" : score.total >= 65 ? "B+" : score.total >= 55 ? "B" : score.total >= 45 ? "C+" : score.total >= 35 ? "C" : "D",
+      });
+    }
+  }
+
+  // Sort by score descending
+  all.sort((a, b) => b.score - a.score);
+
+  return all.slice(0, maxResults);
+}

package/src/core/features/grouping.ts

@@ -0,0 +1,94 @@
+/**
+ * Smart domain grouping — automatically categorize similar domains
+ */
+
+const STRIP_PREFIXES = ["get", "try", "use", "go", "my", "the", "hey", "super", "hyper", "ultra", "mega", "meta", "neo"];
+const STRIP_SUFFIXES = ["app", "hq", "hub", "lab", "labs", "ify", "ize", "box", "kit", "now", "run"];
+
+export interface DomainGroup {
+  baseName: string;
+  domains: string[];
+  available: number;
+  taken: number;
+  expired: number;
+  total: number;
+}
+
+/**
+ * Extract the base/root name from a domain.
+ * "getcoolstartup.com" → "coolstartup"
+ * "coolstartupapp.dev" → "coolstartup"
+ * "my-coolstartup.io" → "coolstartup"
+ */
+export function extractBaseName(domain: string): string {
+  // Get the SLD (second-level domain) — everything before the TLD
+  const parts = domain.toLowerCase().split(".");
+  let name = parts[0] || domain;
+
+  // Remove hyphens for comparison
+  name = name.replace(/-/g, "");
+
+  // Strip known prefixes
+  for (const prefix of STRIP_PREFIXES) {
+    if (name.startsWith(prefix) && name.length > prefix.length + 3) {
+      name = name.slice(prefix.length);
+      break; // Only strip one prefix
+    }
+  }
+
+  // Strip known suffixes
+  for (const suffix of STRIP_SUFFIXES) {
+    if (name.endsWith(suffix) && name.length > suffix.length + 3) {
+      name = name.slice(0, -suffix.length);
+      break; // Only strip one suffix
+    }
+  }
+
+  return name;
+}
+
+/**
+ * Group a list of domain entries by their base name.
+ * Returns groups sorted by size (largest first), with singles at the end.
+ */
+export function groupDomains(
+  domains: Array<{ domain: string; status: string }>
+): DomainGroup[] {
+  const groupMap = new Map<string, DomainGroup>();
+
+  for (const d of domains) {
+    const base = extractBaseName(d.domain);
+
+    let group = groupMap.get(base);
+    if (!group) {
+      group = { baseName: base, domains: [], available: 0, taken: 0, expired: 0, total: 0 };
+      groupMap.set(base, group);
+    }
+
+    group.domains.push(d.domain);
+    group.total++;
+
+    if (d.status === "available") group.available++;
+    else if (d.status === "expired") group.expired++;
+    else if (d.status === "taken") group.taken++;
+  }
+
+  // Sort: multi-domain groups first (by size desc), then singles
+  const groups = Array.from(groupMap.values());
+  groups.sort((a, b) => {
+    if (a.total > 1 && b.total <= 1) return -1;
+    if (a.total <= 1 && b.total > 1) return 1;
+    return b.total - a.total;
+  });
+
+  return groups;
+}
+
+/**
+ * Check if grouping would be useful (more than 1 group with 2+ domains)
+ */
+export function shouldShowGroups(domains: Array<{ domain: string; status: string }>): boolean {
+  if (domains.length < 4) return false;
+  const groups = groupDomains(domains);
+  return groups.filter((g) => g.total >= 2).length >= 1;
+}

package/src/core/features/history.ts

@@ -0,0 +1,163 @@
+/**
+ * Scan history analysis — timeline, diffs, deltas between scans
+ */
+
+import { getScanHistory, getScanById } from "../db.js";
+import type { DomainEntry } from "../types.js";
+
+export interface HistoryEntry {
+  id: number;
+  scannedAt: string;
+  status: string;
+  score: number | null;
+  data: DomainEntry | null;
+}
+
+export interface HistoryDelta {
+  field: string;
+  from: string;
+  to: string;
+  severity: "info" | "warning" | "critical";
+}
+
+export interface HistoryTimeline {
+  domain: string;
+  entries: HistoryEntry[];
+  deltas: HistoryDelta[][]; // deltas[i] = changes between entries[i] and entries[i+1]
+  totalScans: number;
+  firstSeen: string | null;
+  lastSeen: string | null;
+  statusChanges: Array<{ from: string; to: string; at: string }>;
+}
+
+export function getTimeline(domain: string, limit: number = 20): HistoryTimeline {
+  const rawHistory = getScanHistory(domain, limit);
+
+  const entries: HistoryEntry[] = rawHistory.map((h) => ({
+    id: h.id,
+    scannedAt: h.scanned_at,
+    status: h.status,
+    score: h.score,
+    data: null, // loaded on demand
+  }));
+
+  const timeline: HistoryTimeline = {
+    domain,
+    entries,
+    deltas: [],
+    totalScans: entries.length,
+    firstSeen: entries.length > 0 ? entries[entries.length - 1]!.scannedAt : null,
+    lastSeen: entries.length > 0 ? entries[0]!.scannedAt : null,
+    statusChanges: [],
+  };
+
+  // Compute deltas between consecutive scans
+  for (let i = 0; i < entries.length - 1; i++) {
+    const newer = entries[i]!;
+    const older = entries[i + 1]!;
+    const deltas = computeDelta(older, newer, domain);
+    timeline.deltas.push(deltas);
+  }
+
+  // Extract status changes
+  for (let i = entries.length - 1; i > 0; i--) {
+    const older = entries[i]!;
+    const newer = entries[i - 1]!;
+    if (older.status !== newer.status) {
+      timeline.statusChanges.push({
+        from: older.status,
+        to: newer.status,
+        at: newer.scannedAt,
+      });
+    }
+  }
+
+  return timeline;
+}
+
+function computeDelta(_older: HistoryEntry, _newer: HistoryEntry, _domain: string): HistoryDelta[] {
+  const deltas: HistoryDelta[] = [];
+
+  // Status change
+  if (_older.status !== _newer.status) {
+    const severity = (_newer.status === "available" || _newer.status === "expired") ? "critical" : "info";
+    deltas.push({ field: "status", from: _older.status, to: _newer.status, severity });
+  }
+
+  // Score change
+  if (_older.score !== null && _newer.score !== null && _older.score !== _newer.score) {
+    const diff = _newer.score - _older.score;
+    deltas.push({ field: "score", from: `${_older.score}`, to: `${_newer.score} (${diff > 0 ? "+" : ""}${diff})`, severity: "info" });
+  }
+
+  // Load full data for detailed comparison
+  const olderData = getScanById(_older.id);
+  const newerData = getScanById(_newer.id);
+
+  if (olderData && newerData) {
+    // Registrar change
+    const oldReg = olderData.whois?.registrar || olderData.rdap?.registrar || null;
+    const newReg = newerData.whois?.registrar || newerData.rdap?.registrar || null;
+    if (oldReg !== newReg && (oldReg || newReg)) {
+      deltas.push({ field: "registrar", from: oldReg || "none", to: newReg || "none", severity: "warning" });
+    }
+
+    // Expiry date change
+    const oldExp = olderData.whois?.expiryDate || null;
+    const newExp = newerData.whois?.expiryDate || null;
+    if (oldExp !== newExp && (oldExp || newExp)) {
+      deltas.push({ field: "expiry", from: oldExp || "none", to: newExp || "none", severity: "warning" });
+    }
+
+    // Nameserver change
+    const oldNs = (olderData.whois?.nameServers || []).sort().join(", ");
+    const newNs = (newerData.whois?.nameServers || []).sort().join(", ");
+    if (oldNs !== newNs && (oldNs || newNs)) {
+      deltas.push({ field: "nameservers", from: oldNs || "none", to: newNs || "none", severity: "warning" });
+    }
+
+    // IP address change
+    const oldIp = (olderData.dns?.a || []).sort().join(", ");
+    const newIp = (newerData.dns?.a || []).sort().join(", ");
+    if (oldIp !== newIp && (oldIp || newIp)) {
+      deltas.push({ field: "IP (A)", from: oldIp || "none", to: newIp || "none", severity: "info" });
+    }
+
+    // SSL change
+    const oldSsl = olderData.ssl?.issuer || null;
+    const newSsl = newerData.ssl?.issuer || null;
+    if (oldSsl !== newSsl && (oldSsl || newSsl)) {
+      deltas.push({ field: "SSL issuer", from: oldSsl || "none", to: newSsl || "none", severity: "warning" });
+    }
+
+    // HTTP status change
+    const oldHttp = olderData.httpProbe?.status || null;
+    const newHttp = newerData.httpProbe?.status || null;
+    if (oldHttp !== newHttp && (oldHttp || newHttp)) {
+      deltas.push({ field: "HTTP status", from: `${oldHttp || "none"}`, to: `${newHttp || "none"}`, severity: oldHttp === 200 && newHttp !== 200 ? "warning" : "info" });
+    }
+
+    // Tech stack change
+    const oldTech = olderData.techStack?.technologies?.map((t) => t.name).sort().join(", ") || "";
+    const newTech = newerData.techStack?.technologies?.map((t) => t.name).sort().join(", ") || "";
+    if (oldTech !== newTech && (oldTech || newTech)) {
+      deltas.push({ field: "tech stack", from: oldTech || "none", to: newTech || "none", severity: "info" });
+    }
+
+    // Blacklist change
+    const oldBl = olderData.blacklist?.listed || false;
+    const newBl = newerData.blacklist?.listed || false;
+    if (oldBl !== newBl) {
+      deltas.push({ field: "blacklist", from: oldBl ? "listed" : "clean", to: newBl ? "LISTED" : "clean", severity: newBl ? "critical" : "info" });
+    }
+  }
+
+  return deltas;
+}
+
+/**
+ * Load a specific past scan result by ID
+ */
+export function loadHistoryScan(scanId: number): DomainEntry | null {
+  return getScanById(scanId);
+}

package/src/core/validate.ts

@@ -33,6 +33,89 @@ export function sanitizeDomainList(domains: string[]): string[] {
     .filter(isValidDomain);
 }
 
+// ── TLD typo detection ──────────────────────────────────────
+
+const COMMON_TLDS = new Set([
+  "com", "net", "org", "io", "dev", "app", "co", "me", "info", "biz",
+  "xyz", "tech", "ai", "sh", "gg", "cc", "to", "so", "run", "live",
+  "site", "online", "store", "cloud", "pro", "in", "us", "uk", "de",
+  "fr", "jp", "cn", "au", "ca", "nl", "eu", "ru", "br", "it", "es",
+  "se", "no", "fi", "dk", "pl", "cz", "at", "ch", "be", "ie", "nz",
+  "mx", "ar", "cl", "za", "sg", "hk", "tw", "kr", "id", "th", "ph",
+  "edu", "gov", "mil", "int",
+]);
+
+const TLD_CORRECTIONS: Record<string, string> = {
+  "commm": "com", "comm": "com", "con": "com", "vom": "com", "cim": "com", "cm": "com",
+  "conn": "com", "coom": "com", "xom": "com",
+  "nett": "net", "ner": "net", "met": "net",
+  "orgg": "org", "rog": "org",
+  "ioo": "io", "oi": "io",
+  "deev": "dev", "dve": "dev",
+  "appp": "app", "ap": "app",
+};
+
+/**
+ * Detect likely TLD typos and return a corrected domain, or null if no typo detected.
+ */
+export function detectTldTypo(domain: string): string | null {
+  const parts = domain.toLowerCase().split(".");
+  if (parts.length < 2) return null;
+  const tld = parts[parts.length - 1]!;
+
+  // Check known corrections
+  const correction = TLD_CORRECTIONS[tld];
+  if (correction) {
+    return parts.slice(0, -1).join(".") + "." + correction;
+  }
+
+  // Check if TLD exists in common list — no suggestion needed
+  if (!COMMON_TLDS.has(tld)) {
+    // Try to find closest match (simple 1-char edit distance)
+    for (const known of COMMON_TLDS) {
+      if (Math.abs(tld.length - known.length) <= 1 && levenshtein1(tld, known)) {
+        return parts.slice(0, -1).join(".") + "." + known;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if two strings differ by at most 1 edit (insert, delete, or substitute)
+ */
+function levenshtein1(a: string, b: string): boolean {
+  if (a === b) return true;
+  if (Math.abs(a.length - b.length) > 1) return false;
+
+  if (a.length === b.length) {
+    // Check for single substitution
+    let diffs = 0;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) diffs++;
+      if (diffs > 1) return false;
+    }
+    return diffs === 1;
+  }
+
+  // Check for single insert/delete
+  const longer = a.length > b.length ? a : b;
+  const shorter = a.length > b.length ? b : a;
+  let i = 0, j = 0, diffs = 0;
+  while (i < longer.length && j < shorter.length) {
+    if (longer[i] !== shorter[j]) {
+      diffs++;
+      if (diffs > 1) return false;
+      i++;
+    } else {
+      i++;
+      j++;
+    }
+  }
+  return true;
+}
+
 /**
  * Check if a string is a valid session ID (alphanumeric + hyphens, max 100 chars)
  */

package/src/core/whois.ts

@@ -158,15 +158,19 @@ export async function whoisLookup(domain: string): Promise<WhoisResult> {
   assertValidDomain(domain);
   try {
     const { stdout, stderr } = await execFileAsync("whois", [domain], {
-      timeout: 15000,
+      timeout: 20000,
     });
 
     const raw = stdout || stderr || "";
     return parseWhoisResponse(domain, raw);
-  } catch (err: any) {
+  } catch (err: unknown) {
     // whois command may return non-zero but still have useful output
-    if (err.stdout) {
-      return parseWhoisResponse(domain, err.stdout);
+    const execErr = err as { stdout?: string; stderr?: string; message?: string };
+    if (execErr.stdout) {
+      return parseWhoisResponse(domain, execErr.stdout);
+    }
+    if (execErr.stderr) {
+      return parseWhoisResponse(domain, execErr.stderr);
     }
     return {
       domain,
@@ -179,7 +183,7 @@ export async function whoisLookup(domain: string): Promise<WhoisResult> {
       status: [],
       nameServers: [],
       rawText: "",
-      error: err.message || "WHOIS lookup failed",
+      error: execErr.message || "WHOIS lookup failed",
     };
   }
 }

package/src/index.tsx

@@ -7,7 +7,7 @@ import { lookupDns } from "./core/features/dns-details.js";
 import { httpProbe } from "./core/features/http-probe.js";
 import { checkWayback } from "./core/features/wayback.js";
 import { calculateDomainAge } from "./core/features/domain-age.js";
-import { sanitizeDomainList, safePath } from "./core/validate.js";
+import { sanitizeDomainList, safePath, detectTldTypo } from "./core/validate.js";
 import { bashCompletions, zshCompletions, fishCompletions } from "./completions.js";
 import { checkSocialMedia } from "./core/features/social-check.js";
 import { detectTechStack } from "./core/features/tech-stack.js";
@@ -43,7 +43,7 @@ const program = new Command();
 program
   .name("dsniper")
   .description("All-in-one domain intelligence toolkit — availability checker, security recon, portfolio manager")
-  .version("0.1.2")
+  .version("0.2.0")
   .argument("[domains...]", "Domain(s) to check")
   .option("-f, --file <path>", "Path to file with domains (one per line)")
   .option("-a, --auto-register", "Automatically register available domains", false)
@@ -112,29 +112,53 @@ program
 program
   .command("suggest <keyword>")
   .description("Generate domain name suggestions from a keyword")
-  .option("-t, --tld <tld>", "TLD to use", "com")
+  .option("-t, --tld <tld>", "TLD or 'all' for multi-TLD", "com")
   .option("-n, --count <n>", "Number of suggestions", "20")
   .option("--check", "Check availability of suggestions", false)
   .action(async (keyword: string, opts: { tld: string; count: string; check: boolean }) => {
-    const { generateSuggestions } = await import("./core/features/domain-suggest.js");
-    const suggestions = generateSuggestions(keyword, opts.tld, parseInt(opts.count, 10));
+    const { generateScoredSuggestions } = await import("./core/features/domain-suggest.js");
+    const tlds = opts.tld === "all" ? ["com", "io", "dev", "app", "co", "net", "org", "me", "sh", "gg"] : [opts.tld];
+    const suggestions = generateScoredSuggestions(keyword, tlds, parseInt(opts.count, 10));
 
     if (opts.check) {
       const { whoisLookup } = await import("./core/whois.js");
       console.log(`\nChecking ${suggestions.length} suggestions for "${keyword}"...\n`);
-      for (const s of suggestions) {
-        const whois = await whoisLookup(s.domain);
-        const status = whois.available ? "\x1b[32mAVAILABLE\x1b[0m" : "\x1b[31mTAKEN\x1b[0m";
-        console.log(`  ${status}  ${s.domain}  (${s.strategy})`);
-        await new Promise((r) => setTimeout(r, 1000));
+
+      // Concurrent check (5 at a time)
+      const CONCURRENCY = 5;
+      const results: Array<{ domain: string; strategy: string; available: boolean; score: number; grade: string }> = [];
+
+      for (let i = 0; i < suggestions.length; i += CONCURRENCY) {
+        const batch = suggestions.slice(i, i + CONCURRENCY);
+        const batchResults = await Promise.all(
+          batch.map(async (s) => {
+            const whois = await whoisLookup(s.domain);
+            return { domain: s.domain, strategy: s.strategy, available: whois.available, score: s.score, grade: s.grade };
+          })
+        );
+        results.push(...batchResults);
+      }
+
+      // Sort: available first, then by score
+      results.sort((a, b) => {
+        if (a.available && !b.available) return -1;
+        if (!a.available && b.available) return 1;
+        return b.score - a.score;
+      });
+
+      for (const r of results) {
+        const status = r.available ? "\x1b[32mAVAILABLE\x1b[0m" : "\x1b[31mTAKEN\x1b[0m";
+        console.log(`  ${status}  ${r.grade.padEnd(3)} ${r.domain.padEnd(30)} (${r.strategy})`);
       }
+      console.log(`\n  ${results.filter(r => r.available).length} available out of ${results.length} checked\n`);
     } else {
-      console.log(`\nSuggestions for "${keyword}" (.${opts.tld}):\n`);
+      // No check — just list suggestions with scores
+      console.log(`\nSuggestions for "${keyword}":\n`);
       for (const s of suggestions) {
-        console.log(`  ${s.domain}  (${s.strategy})`);
+        console.log(`  ${s.grade.padEnd(3)} ${s.domain.padEnd(30)} (${s.strategy})`);
       }
+      console.log();
     }
-    console.log();
   });
 
 // ─── Portfolio subcommand ────────────────────────────────
@@ -1475,6 +1499,39 @@ program
     }
   });
 
+// ─── Update subcommand ──────────────────────────────────
+
+program
+  .command("update")
+  .description("Update domsniper to the latest version")
+  .action(async () => {
+    const { checkForUpdates } = await import("./core/features/version-check.js");
+    const result = await checkForUpdates();
+
+    if (!result.updateAvailable || !result.latest) {
+      console.log(`Already on the latest version (${result.current})`);
+      return;
+    }
+
+    console.log(`Updating: ${result.current} → ${result.latest}`);
+
+    const { execSync } = await import("child_process");
+    try {
+      // Try bun first, then npm
+      try {
+        execSync("bun add -g domsniper@latest", { stdio: "inherit" });
+      } catch {
+        execSync("npm install -g domsniper@latest", { stdio: "inherit" });
+      }
+      console.log(`\nUpdated to domsniper@${result.latest}`);
+    } catch (err: unknown) {
+      console.error("Update failed. Try manually:");
+      console.error("  bun add -g domsniper@latest");
+      console.error("  # or: npm install -g domsniper@latest");
+      process.exit(1);
+    }
+  });
+
 program.parse();
 
 // ─── Types ───────────────────────────────────────────────
@@ -1566,9 +1623,27 @@ async function runHeadless(domains: string[], options: CliOptions) {
     domainList.push(...parseDomainList(content));
   }
 
+  // Auto-detect and correct TLD typos before sanitization
+  const rawList = [...domainList];
+  domainList = domainList.map((d) => {
+    const suggestion = detectTldTypo(d);
+    if (suggestion) {
+      console.error(`  Typo? "${d}" → auto-corrected to "${suggestion}"`);
+      return suggestion;
+    }
+    return d;
+  });
+
   const rawCount = domainList.length;
   domainList = sanitizeDomainList(domainList);
 
+  // Deduplicate
+  const beforeDedup = domainList.length;
+  domainList = [...new Set(domainList)];
+  if (domainList.length < beforeDedup) {
+    console.error(`  Removed ${beforeDedup - domainList.length} duplicate(s)`);
+  }
+
   if (domainList.length === 0) {
     if (rawCount > 0) {
       console.error(`No valid domains found (${rawCount} input(s) rejected). Domains must be like: example.com`);