domainstorm 0.2.2 → 0.2.4

package/README.md

@@ -19,7 +19,7 @@ It is built for AI and agent products where naming cycles happen fast and every
 ## Install
 
 ```bash
-npm i -g domainstorm
+npm i -g domainstorm@latest
 ```
 
 Run instantly without global install:
@@ -28,21 +28,27 @@ Run instantly without global install:
 npx --yes domainstorm --help
 ```
 
+Update to latest:
+
+```bash
+npm update -g domainstorm
+```
+
 ## Quick Wins
 
 Brainstorm + check + return only likely available:
 
 ```bash
-domainstorm --brainstorm "agent orchestration" "mcp broker" --tld md --server whois.nic.md --only-available --table
+domainstorm --brainstorm "agent orchestration" "mcp broker" --tld md --server whois.nic.md --dns-prefilter --only-available --table
 ```
 
 Check exact domains:
 
 ```bash
-domainstorm agentmesh.ai agentmesh.com agentmesh.md
+domainstorm broker.md --server whois.nic.md --dns-prefilter
 ```
 
-Default output is plain English (for example: `broker.md is available.`).
+Default output is plain English (for example: `✅ broker.md is available.`).
 Use `--table` if you want a structured table view.
 
 Check from file and export CSV:
@@ -73,11 +79,29 @@ Compatibility alias:
 domain-check --help
 ```
 
+## Local Dev Test (npm)
+
+Run the current repo version without publishing:
+
+```bash
+npm run check
+npm link
+domainstorm --help
+domainstorm broker.md --table
+```
+
+Remove local link when done:
+
+```bash
+npm unlink -g domainstorm
+```
+
 ## Example Output
 
 ```txt
-agentmesh.md    likely_available    availability_pattern_match    low    story=Keyword + product framing
-agentops.md     registered          registration_pattern_match    low    story=Keyword + product framing
+✅ broker.md is available.
+❌ agentops.md is not available (already registered).
+Summary: ✅ 1 available, ❌ 1 taken, ⚠️ 0 unknown.
 ```
 
 Output columns:
@@ -85,6 +109,7 @@ Output columns:
 - `domain`
 - `status` (`registered`, `likely_available`, `unknown`)
 - `reason`
+- `state` (registry/DNS state when available)
 - `legal_risk` (`low`, `high_tm_risk`)
 - `story` (brainstorm narrative tag)
 - `error`
@@ -94,57 +119,28 @@ Output columns:
 - `--brainstorm` / `--storm`
 - `--max-suggestions <n>` (default: `120`)
 - `--table`
+- `--plain`
 - `--input <file>`
 - `--output <file>`
 - `--tld <tld>` (default: `md`)
 - `--server <whois-host>`
+- `--dns-prefilter`
 - `--only-available`
 - `--concurrency <n>`
 - `--timeout-ms <n>`
 - `--raw`
 
-## Add `NPM_TOKEN` In GitHub (2 Minutes)
-
-1. Create an npm Automation token:
-`npmjs.com -> Account Settings -> Access Tokens -> Generate New Token -> Automation`
-2. Open your repo:
-`github.com/tanishqsh/domain-cli`
-3. Go to:
-`Settings -> Secrets and variables -> Actions`
-4. Click:
-`New repository secret`
-5. Set:
-`Name = NPM_TOKEN`
-`Secret = <your npm automation token>`
-6. Save.
-
-Now GitHub Actions can publish with `.github/workflows/npm-publish.yml`.
-
-## GitHub -> npm Auto Publish
-
-The publish workflow triggers on:
-
-- GitHub Release published
-- Manual `workflow_dispatch`
-
-Workflow path:
-
-`/.github/workflows/npm-publish.yml`
-
-Important:
-
-- Bump `package.json` version before publishing a new release
-- npm will reject already-published versions
-
-## Local Publish
-
-```bash
-npm login
-npm publish --access public
-```
-
 ## Notes
 
 - WHOIS formats vary by registry; treat `likely_available` as a pre-check, not final registrar checkout.
 - Registries can rate-limit bulk lookups; retry `unknown` rows after cooldown.
+- Domainstorm includes registry adapters for `.md`, `.com`, `.org`, and `.ai` to improve state parsing.
+- Domainstorm auto-throttles WHOIS to concurrency `2` across TLDs (override with `--concurrency`).
+- For `.md`, `Domain state` is parsed explicitly (`Inactive`, `OK`, `OK Delegated`, and no-match states).
+- `--dns-prefilter` runs DNS first and marks resolving domains as taken before WHOIS (faster and lighter on WHOIS quota).
 - Install `whois` locally (`brew install whois` on macOS).
+
+## Maintainers
+
+Maintainer-only release and CI publishing instructions are in:
+`MAINTAINERS.md`

package/check-domains.mjs

@@ -5,9 +5,11 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 
 const DEFAULT_CONCURRENCY = 6;
+const SAFE_WHOIS_CONCURRENCY = 2;
 const DEFAULT_TIMEOUT_MS = 12000;
 const DEFAULT_TLD = "md";
 const DEFAULT_MAX_SUGGESTIONS = 120;
+const MD_WHOIS_SERVER = "whois.nic.md";
 const AVAILABILITY_PATTERNS = [
   "no match for",
   "not found",
@@ -112,8 +114,9 @@ function printUsage() {
       "  --output <file>        Optional CSV output path",
       "  --tld <tld>            Default TLD for bare labels (default: md)",
       "  --server <host>        Optional WHOIS server (ex: whois.nic.md)",
-      "  --concurrency <n>      Parallel WHOIS requests (default: 6)",
+      "  --concurrency <n>      Parallel WHOIS requests (default: 6, auto-throttled to 2 unless set)",
       "  --timeout-ms <n>       WHOIS timeout per domain (default: 12000)",
+      "  --dns-prefilter        Run DNS pre-check (A/AAAA/CNAME); skip WHOIS for resolving domains",
       "  --brainstorm           Generate domain ideas from seeds, then check availability",
       "  --max-suggestions <n>  Max brainstormed candidates (default: 120)",
       "  --table                Render results in a readable terminal table",
@@ -124,6 +127,7 @@ function printUsage() {
       "",
       "Notes:",
       "  - Labels without a dot are auto-converted to <label>.<tld>",
+      "  - WHOIS is auto-throttled to concurrency=2 unless you set --concurrency",
       "  - Brainstorm mode uses your seed words only (no hardcoded keyword packs)",
       "  - No seed ideas? Ask your agent (Codex, Claude, etc.) and pass them to --brainstorm",
       "  - WHOIS-based checks are heuristic; always confirm at registrar checkout",
@@ -136,9 +140,11 @@ function parseArgs(argv) {
     input: null,
     output: null,
     concurrency: DEFAULT_CONCURRENCY,
+    concurrencyExplicit: false,
     timeoutMs: DEFAULT_TIMEOUT_MS,
     tld: DEFAULT_TLD,
     server: null,
+    dnsPrefilter: false,
     brainstorm: false,
     maxSuggestions: DEFAULT_MAX_SUGGESTIONS,
     table: false,
@@ -162,6 +168,7 @@ function parseArgs(argv) {
       case "--concurrency":
       case "-c":
         options.concurrency = Number.parseInt(argv[++i], 10);
+        options.concurrencyExplicit = true;
         break;
       case "--tld":
         options.tld = argv[++i];
@@ -172,6 +179,9 @@ function parseArgs(argv) {
       case "--timeout-ms":
         options.timeoutMs = Number.parseInt(argv[++i], 10);
         break;
+      case "--dns-prefilter":
+        options.dnsPrefilter = true;
+        break;
       case "--brainstorm":
       case "--storm":
         options.brainstorm = true;
@@ -409,7 +419,98 @@ function brainstormCandidates(rawSeeds, maxSuggestions) {
   };
 }
 
-function classifyWhois(raw) {
+function isMdDomain(domain) {
+  return domain.endsWith(".md");
+}
+
+function getDomainTld(domain) {
+  const idx = domain.lastIndexOf(".");
+  if (idx < 0 || idx === domain.length - 1) {
+    return "";
+  }
+  return domain.slice(idx + 1).toLowerCase();
+}
+
+function shouldUseMdRules(domain, server) {
+  if (isMdDomain(domain)) {
+    return true;
+  }
+  if (!server) {
+    return false;
+  }
+  return server === MD_WHOIS_SERVER || server.endsWith(".nic.md") || server.endsWith(".md");
+}
+
+function classifyMdWhois(raw) {
+  const text = raw.toLowerCase();
+  if (
+    text.includes("no entries found [ no match for ]") ||
+    (text.includes("no entries found") && text.includes("no match for"))
+  ) {
+    return {
+      status: "likely_available",
+      reason: "md_no_match",
+      state: "No match",
+    };
+  }
+
+  const stateMatch = raw.match(/domain state:\s*([^\r\n]+)/i);
+  if (!stateMatch) {
+    return null;
+  }
+
+  const state = stateMatch[1].trim();
+  const lower = state.toLowerCase();
+  if (lower.includes("inactive")) {
+    return { status: "registered", reason: "md_state_inactive", state };
+  }
+  if (lower.includes("ok delegated")) {
+    return { status: "registered", reason: "md_state_ok_delegated", state };
+  }
+  if (lower === "ok" || lower.startsWith("ok ")) {
+    return { status: "registered", reason: "md_state_ok", state };
+  }
+  return { status: "registered", reason: "md_state_registered", state };
+}
+
+function cleanDomainStatus(value) {
+  return value
+    .replace(/\s+https?:\/\/\S+$/i, "")
+    .replace(/\s+\(https?:\/\/\S+\)$/i, "")
+    .trim();
+}
+
+function classifyComOrgAiWhois(raw, domain) {
+  const tld = getDomainTld(domain);
+  if (!["com", "org", "ai"].includes(tld)) {
+    return null;
+  }
+
+  const text = raw.toLowerCase();
+  if (tld === "com" && text.includes('no match for domain "')) {
+    return { status: "likely_available", reason: "com_no_match", state: "No match" };
+  }
+  if ((tld === "org" || tld === "ai") && text.includes("domain not found")) {
+    return { status: "likely_available", reason: `${tld}_domain_not_found`, state: "No match" };
+  }
+
+  const statusMatch = raw.match(/Domain Status:\s*([^\r\n]+)/i);
+  if (statusMatch) {
+    return {
+      status: "registered",
+      reason: `${tld}_domain_status`,
+      state: cleanDomainStatus(statusMatch[1]),
+    };
+  }
+
+  if (/Domain Name:\s*[^\r\n]+/i.test(raw) || /Registry Domain ID:\s*[^\r\n]+/i.test(raw)) {
+    return { status: "registered", reason: `${tld}_registered`, state: "" };
+  }
+
+  return null;
+}
+
+function classifyWhois(raw, domain, server) {
   const text = raw.toLowerCase();
   if (!text.trim()) {
     return { status: "unknown", reason: "empty_whois_response" };
@@ -420,6 +521,16 @@ function classifyWhois(raw) {
   if (RATE_LIMIT_PATTERNS.some((p) => text.includes(p))) {
     return { status: "unknown", reason: "rate_limited_or_blocked" };
   }
+  if (shouldUseMdRules(domain, server)) {
+    const md = classifyMdWhois(raw);
+    if (md) {
+      return md;
+    }
+  }
+  const common = classifyComOrgAiWhois(raw, domain);
+  if (common) {
+    return common;
+  }
   if (AVAILABILITY_PATTERNS.some((p) => text.includes(p))) {
     return { status: "likely_available", reason: "availability_pattern_match" };
   }
@@ -429,6 +540,75 @@ function classifyWhois(raw) {
   return { status: "unknown", reason: "unrecognized_whois_format" };
 }
 
+function runDigType(domain, type, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn("dig", ["+short", domain, type], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+    const timer = setTimeout(() => {
+      if (done) {
+        return;
+      }
+      done = true;
+      child.kill("SIGKILL");
+      resolve({ values: [], error: `dig ${type} timeout` });
+    }, Math.min(timeoutMs, 5000));
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      resolve({ values: [], error: err.message });
+    });
+    child.on("close", () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      const values = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+      resolve({ values, error: stderr.trim() || null });
+    });
+  });
+}
+
+async function runDnsPrefilter(domain, timeoutMs) {
+  const a = await runDigType(domain, "A", timeoutMs);
+  if (a.values.length > 0) {
+    return { domain, resolves: true, recordType: "A", values: a.values, error: null };
+  }
+  const aaaa = await runDigType(domain, "AAAA", timeoutMs);
+  if (aaaa.values.length > 0) {
+    return { domain, resolves: true, recordType: "AAAA", values: aaaa.values, error: null };
+  }
+  const cname = await runDigType(domain, "CNAME", timeoutMs);
+  if (cname.values.length > 0) {
+    return { domain, resolves: true, recordType: "CNAME", values: cname.values, error: null };
+  }
+  return {
+    domain,
+    resolves: false,
+    recordType: "",
+    values: [],
+    error: a.error || aaaa.error || cname.error || null,
+  };
+}
+
 function runWhois(domain, timeoutMs, server) {
   return new Promise((resolve) => {
     const args = server ? ["-h", server, domain] : [domain];
@@ -483,12 +663,13 @@ function runWhois(domain, timeoutMs, server) {
       done = true;
       clearTimeout(timer);
       const merged = [stdout, stderr].filter(Boolean).join("\n");
-      const classification = classifyWhois(merged);
+      const classification = classifyWhois(merged, domain, server);
       const stderrText = stderr.trim();
       resolve({
         domain,
         status: classification.status,
         reason: classification.reason,
+        state: classification.state ?? "",
         raw: merged.trim(),
         error: classification.reason === "whois_lookup_failed" ? stderrText || "WHOIS lookup failed" : null,
       });
@@ -528,7 +709,7 @@ async function maybeWriteCsv(results, outputPath) {
   if (!outputPath) {
     return;
   }
-  const header = ["domain", "status", "reason", "legal_risk", "story", "error"];
+  const header = ["domain", "status", "reason", "state", "legal_risk", "story", "error"];
   const lines = [header.join(",")];
   for (const row of results) {
     lines.push(
@@ -536,6 +717,7 @@ async function maybeWriteCsv(results, outputPath) {
         row.domain,
         row.status,
         row.reason,
+        row.state ?? "",
         row.legalRisk,
         row.story ?? "",
         row.error ?? "",
@@ -570,22 +752,37 @@ function snippet(raw) {
 function verdictForStatus(status) {
   switch (status) {
     case "likely_available":
-      return "AVAILABLE";
+      return "✅ AVAILABLE";
     case "registered":
-      return "TAKEN";
+      return "❌ TAKEN";
     default:
-      return "UNKNOWN";
+      return "⚠️ UNKNOWN";
   }
 }
 
 function sentenceForRow(row) {
   if (row.status === "likely_available") {
-    return `${row.domain} is available.`;
+    return `✅ ${row.domain} is available.`;
   }
   if (row.status === "registered") {
-    return `${row.domain} is not available (already registered).`;
+    if (row.reason === "dns_resolves_prefilter") {
+      return `❌ ${row.domain} is not available (DNS resolves).`;
+    }
+    if (row.reason === "md_state_inactive") {
+      return `❌ ${row.domain} is not available (registered, inactive).`;
+    }
+    if (row.reason === "md_state_ok") {
+      return `❌ ${row.domain} is not available (registered, state: OK).`;
+    }
+    if (row.reason === "md_state_ok_delegated") {
+      return `❌ ${row.domain} is not available (registered, state: OK Delegated).`;
+    }
+    if (row.state) {
+      return `❌ ${row.domain} is not available (registered, state: ${row.state}).`;
+    }
+    return `❌ ${row.domain} is not available (already registered).`;
   }
-  return `${row.domain} availability is unknown (whois could not confirm).`;
+  return `⚠️ ${row.domain} availability is unknown (whois could not confirm).`;
 }
 
 function toDisplayRow(row, options) {
@@ -593,6 +790,7 @@ function toDisplayRow(row, options) {
     verdict: verdictForStatus(row.status),
     domain: row.domain,
     whois: row.status,
+    state: row.state ?? "",
     reason: row.reason,
     risk: row.legalRisk,
     story: row.story ?? "",
@@ -614,12 +812,14 @@ function truncateCell(value, maxWidth) {
 
 function printTable(rows, options) {
   const displayRows = rows.map((row) => toDisplayRow(row, options));
+  const hasState = displayRows.some((row) => row.state);
   const hasStory = displayRows.some((row) => row.story);
   const hasError = displayRows.some((row) => row.error);
   const columns = [
-    { key: "verdict", label: "Verdict", maxWidth: 10 },
+    { key: "verdict", label: "Verdict", maxWidth: 14 },
     { key: "domain", label: "Domain", maxWidth: 44 },
     { key: "whois", label: "Whois", maxWidth: 18 },
+    ...(hasState ? [{ key: "state", label: "State", maxWidth: 22 }] : []),
     { key: "reason", label: "Reason", maxWidth: 34 },
     { key: "risk", label: "Risk", maxWidth: 14 },
     ...(hasStory ? [{ key: "story", label: "Story", maxWidth: 36 }] : []),
@@ -686,6 +886,13 @@ function printNarrativeResults(rows, options) {
   }
 }
 
+function shouldAutoThrottleWhois(domains) {
+  if (domains.length === 0) {
+    return false;
+  }
+  return true;
+}
+
 async function main() {
   const options = parseArgs(process.argv.slice(2));
   let rawLabels = await loadLabels(options);
@@ -720,11 +927,56 @@ async function main() {
     throw new Error("No valid domains found after normalization.");
   }
 
+  const effectiveConcurrency =
+    !options.concurrencyExplicit && shouldAutoThrottleWhois(domains)
+      ? Math.min(options.concurrency, SAFE_WHOIS_CONCURRENCY)
+      : options.concurrency;
+
+  if (effectiveConcurrency !== options.concurrency) {
+    console.error(
+      `Auto-throttle: using concurrency=${effectiveConcurrency} for WHOIS (override with --concurrency).`,
+    );
+  }
+
   const serverLabel = options.server ? `server=${options.server}` : "server=auto";
-  console.error(`Checking ${domains.length} domain(s) (${serverLabel}) with concurrency=${options.concurrency}`);
+  console.error(`Checking ${domains.length} domain(s) (${serverLabel}) with concurrency=${effectiveConcurrency}`);
+
+  const dnsPrefilterResults = [];
+  let whoisTargets = domains;
+  if (options.dnsPrefilter) {
+    const dnsConcurrency = options.concurrencyExplicit ? options.concurrency : Math.min(20, domains.length || 1);
+    const dnsChecks = await mapLimit(domains, dnsConcurrency, async (domain) =>
+      runDnsPrefilter(domain, options.timeoutMs),
+    );
+
+    const dnsTaken = dnsChecks.filter((item) => item.resolves);
+    if (dnsTaken.length > 0) {
+      console.error(`DNS prefilter: ${dnsTaken.length} domain(s) resolve; marked as taken without WHOIS.`);
+    }
+
+    for (const item of dnsTaken) {
+      dnsPrefilterResults.push({
+        domain: item.domain,
+        status: "registered",
+        reason: "dns_resolves_prefilter",
+        state: `DNS ${item.recordType}`,
+        raw: "",
+        error: null,
+      });
+    }
+    whoisTargets = dnsChecks.filter((item) => !item.resolves).map((item) => item.domain);
+  }
 
-  const checked = await mapLimit(domains, options.concurrency, async (domain) => {
-    const result = await runWhois(domain, options.timeoutMs, options.server);
+  const whoisResults = await mapLimit(whoisTargets, effectiveConcurrency, async (domain) =>
+    runWhois(domain, options.timeoutMs, options.server),
+  );
+
+  const mergedByDomain = new Map();
+  for (const result of [...dnsPrefilterResults, ...whoisResults]) {
+    mergedByDomain.set(result.domain, result);
+  }
+  const checked = domains.map((domain) => {
+    const result = mergedByDomain.get(domain);
     const label = domain.slice(0, domain.lastIndexOf("."));
     return {
       ...result,
@@ -740,6 +992,9 @@ async function main() {
   if (options.plain) {
     for (const row of filtered) {
       let line = `${row.domain}\t${row.status}\t${row.reason}\t${row.legalRisk}`;
+      if (row.state) {
+        line += `\tstate=${row.state}`;
+      }
       if (row.story) {
         line += `\tstory=${row.story}`;
       }
@@ -760,7 +1015,7 @@ async function main() {
   await maybeWriteCsv(checked, options.output);
 
   const counts = summarize(checked);
-  console.error(`Summary: ${counts.likelyAvailable} available, ${counts.registered} taken, ${counts.unknown} unknown.`);
+  console.error(`Summary: ✅ ${counts.likelyAvailable} available, ❌ ${counts.registered} taken, ⚠️ ${counts.unknown} unknown.`);
   if (options.output) {
     console.error(`CSV written: ${path.resolve(options.output)}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domainstorm",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Brainstorm and check domain names in one command.",
   "repository": {
     "type": "git",