domainstorm 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tanishq Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# Domainstorm CLI
+
+`domainstorm` is a domain brainstorming + availability CLI for agent products.
+One command can generate naming candidates and check registration status via WHOIS.
+
+## Install
+
+From GitHub (works now):
+
+```bash
+npm i -g github:tanishqsh/domain-cli
+```
+
+From npm (after publish):
+
+```bash
+npm i -g domainstorm
+```
+
+Run without installing globally:
+
+```bash
+npx --yes github:tanishqsh/domain-cli#main --help
+```
+
+## One-Command Brainstorm
+
+```bash
+domainstorm --brainstorm "agent cli" "mcp broker" --tld md --server whois.nic.md --only-available
+```
+
+This command:
+- Generates brandable name candidates from your seed phrases
+- Appends your target TLD
+- Checks registration status
+- Prints a narrative hint (`story=...`) for each candidate
+
+## Quick Start
+
+```bash
+domainstorm openai.com example.org --output /tmp/domain-results.csv
+```
+
+```bash
+domainstorm --input agent-md-candidates.txt --tld md --server whois.nic.md --output /tmp/md-results.csv
+```
+
+`domain-check` is kept as a compatibility alias.
+
+## Input Format
+
+- One label/domain per line in a text file
+- `#` comments are ignored
+- Labels without a TLD are converted to `<label>.<tld>` (default: `md`)
+- Comma-separated values are accepted per line
+
+Example:
+
+```txt
+# sample
+broker
+agenthub.md
+mcpbroker,mcprouter
+```
+
+## Output Columns
+
+- `domain`
+- `status`: `registered`, `likely_available`, or `unknown`
+- `reason`: why the status was chosen
+- `legal_risk`: heuristic trademark risk flag (`low` / `high_tm_risk`)
+- `story`: brainstorm narrative tag for generated names
+- `error`: lookup/system failures when present
+
+## CLI Flags
+
+- `--input <file>`
+- `--output <file>`
+- `--tld <tld>` default `md`
+- `--server <whois-host>` optional (for example `whois.nic.md`)
+- `--concurrency <n>`
+- `--timeout-ms <n>`
+- `--brainstorm` / `--storm`
+- `--max-suggestions <n>` default `120`
+- `--only-available`
+- `--raw`
+
+## Notes
+
+- WHOIS formats vary by registry; treat `likely_available` as a pre-check, not final registrar confirmation.
+- Registries can rate-limit bulk lookups; retry unknown rows after cooldown.
+- `whois` must be installed locally (`brew install whois` on macOS).
+
+## Publish To npm
+
+```bash
+npm login
+npm publish --access public
+```

package/agent-md-candidates.txt

@@ -0,0 +1,117 @@
+# Generic agent/AI-adjacent names (avoid trademarked brand terms)
+agent
+agents
+agentic
+broker
+router
+gateway
+mesh
+hub
+stack
+runtime
+engine
+studio
+labs
+forge
+protocol
+tooling
+tool
+tools
+plugin
+plugins
+automation
+workflow
+workflows
+pipeline
+pipelines
+memory
+context
+prompt
+prompts
+rag
+vector
+vectors
+embedding
+embeddings
+inference
+eval
+evals
+benchmark
+guardrails
+safety
+security
+audit
+monitor
+observability
+telemetry
+trace
+search
+retrieval
+knowledge
+graph
+scheduler
+cache
+compute
+gpu
+token
+tokens
+agenthub
+agentstack
+agentcloud
+agentmesh
+agentruntime
+agentengine
+agentstudio
+agentforge
+agentflow
+agentops
+agentinfra
+agentprotocol
+agentregistry
+agentdirectory
+agentmarket
+agentstore
+agenthosting
+agentdeploy
+agentsecurity
+agentguard
+agentaudit
+agenttrace
+agentmonitor
+agentmemory
+agentcontext
+agentsearch
+agentrag
+agentvector
+agenteval
+agentbench
+agentapi
+agentsdk
+agenttools
+agentplugin
+agentintegrations
+agentconnectors
+agentnetwork
+agentgateway
+agentrouter
+agentbroker
+mcp
+mcpbroker
+mcprouter
+mcpgateway
+mcphub
+mcpregistry
+mcpdirectory
+mcpmarket
+mcptools
+mcpcloud
+mcpstack
+mcpstudio
+mcpruntime
+mcpsecurity
+mcpaudit
+mcpmonitor
+mcpops
+mcpmemory
+mcpcontext
+mcpeval

package/check-md-domains.mjs

@@ -0,0 +1,641 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+const DEFAULT_CONCURRENCY = 6;
+const DEFAULT_TIMEOUT_MS = 12000;
+const DEFAULT_TLD = "md";
+const DEFAULT_MAX_SUGGESTIONS = 120;
+const AVAILABILITY_PATTERNS = [
+  "no match for",
+  "not found",
+  "no entries found",
+  "domain not found",
+  "no data found",
+  "no object found",
+  "object does not exist",
+  "no such domain",
+  "status: free",
+  "status: available",
+  "available",
+];
+const REGISTRATION_PATTERNS = [
+  "domain  name:",
+  "domain name:",
+  "domain:",
+  "registry domain id:",
+  "whois:",
+  "registrar:",
+  "creation date:",
+  "expiry date:",
+  "expiration date:",
+  "registered on:",
+  "expires on:",
+  "domain state:",
+  "nameserver:",
+];
+const RATE_LIMIT_PATTERNS = [
+  "limit exceeded",
+  "too many requests",
+  "try again later",
+  "rate limit",
+  "blocked",
+];
+const LOOKUP_ERROR_PATTERNS = [
+  "nodename nor servname provided",
+  "temporary failure in name resolution",
+  "name or service not known",
+  "connection timed out",
+  "unable to connect",
+  "no route to host",
+  "network is unreachable",
+];
+
+const STOP_WORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "for",
+  "to",
+  "of",
+  "by",
+  "with",
+  "on",
+  "in",
+  "at",
+  "from",
+  "your",
+  "our",
+  "my",
+  "agent",
+  "agents",
+]);
+
+const DEFAULT_STORM_SEEDS = [
+  "agent",
+  "mcp",
+  "ai",
+  "broker",
+  "router",
+  "runtime",
+  "ops",
+  "stack",
+  "forge",
+  "mesh",
+  "pilot",
+  "flow",
+];
+
+const STORM_SUFFIXES = [
+  "storm",
+  "ops",
+  "hub",
+  "mesh",
+  "forge",
+  "stack",
+  "pilot",
+  "route",
+  "router",
+  "broker",
+  "runtime",
+  "engine",
+  "works",
+  "cloud",
+  "grid",
+  "terminal",
+  "dock",
+  "labs",
+  "studio",
+];
+
+const STORM_PREFIXES = [
+  "agent",
+  "ai",
+  "mcp",
+  "task",
+  "flow",
+  "auto",
+  "tool",
+  "prompt",
+  "context",
+  "trace",
+  "guard",
+  "secure",
+  "fleet",
+];
+
+// Small, non-authoritative heuristic list for quick legal-risk triage.
+const TRADEMARK_KEYWORDS = [
+  "openai",
+  "chatgpt",
+  "anthropic",
+  "claude",
+  "google",
+  "gemini",
+  "microsoft",
+  "copilot",
+  "meta",
+  "llama",
+  "apple",
+  "amazon",
+  "aws",
+  "xai",
+  "grok",
+  "nvidia",
+  "intel",
+  "samsung",
+  "tesla",
+  "spacex",
+];
+
+function printUsage() {
+  console.log(
+    [
+      "Usage:",
+      "  domainstorm --input domains.txt [--output results.csv]",
+      "  domainstorm openai.com example.org",
+      "  domainstorm --brainstorm \"agent cli\" \"mcp broker\" --tld md --server whois.nic.md",
+      "",
+      "Options:",
+      "  --input <file>         Text file of domains/labels (one per line, '#' comments supported)",
+      "  --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)",
+      "  --timeout-ms <n>       WHOIS timeout per domain (default: 12000)",
+      "  --brainstorm           Generate domain ideas from seeds, then check availability",
+      "  --max-suggestions <n>  Max brainstormed candidates (default: 120)",
+      "  --only-available       Print only likely available domains",
+      "  --raw                  Include WHOIS snippet in console output",
+      "  --help                 Show this help",
+      "",
+      "Notes:",
+      "  - Labels without a dot are auto-converted to <label>.<tld>",
+      "  - WHOIS-based checks are heuristic; always confirm at registrar checkout",
+    ].join("\n"),
+  );
+}
+
+function parseArgs(argv) {
+  const options = {
+    input: null,
+    output: null,
+    concurrency: DEFAULT_CONCURRENCY,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    tld: DEFAULT_TLD,
+    server: null,
+    brainstorm: false,
+    maxSuggestions: DEFAULT_MAX_SUGGESTIONS,
+    onlyAvailable: false,
+    raw: false,
+    labels: [],
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--input":
+      case "-i":
+        options.input = argv[++i];
+        break;
+      case "--output":
+      case "-o":
+        options.output = argv[++i];
+        break;
+      case "--concurrency":
+      case "-c":
+        options.concurrency = Number.parseInt(argv[++i], 10);
+        break;
+      case "--tld":
+        options.tld = argv[++i];
+        break;
+      case "--server":
+        options.server = argv[++i];
+        break;
+      case "--timeout-ms":
+        options.timeoutMs = Number.parseInt(argv[++i], 10);
+        break;
+      case "--brainstorm":
+      case "--storm":
+        options.brainstorm = true;
+        break;
+      case "--max-suggestions":
+        options.maxSuggestions = Number.parseInt(argv[++i], 10);
+        break;
+      case "--only-available":
+        options.onlyAvailable = true;
+        break;
+      case "--raw":
+        options.raw = true;
+        break;
+      case "--help":
+      case "-h":
+        printUsage();
+        process.exit(0);
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown option: ${arg}`);
+        }
+        if (arg === "storm" || arg === "brainstorm") {
+          options.brainstorm = true;
+          break;
+        }
+        options.labels.push(arg);
+    }
+  }
+
+  if (!options.input && options.labels.length === 0 && !options.brainstorm) {
+    throw new Error("Provide --input <file>, one/more labels/domains, or use --brainstorm.");
+  }
+  if (!Number.isInteger(options.concurrency) || options.concurrency < 1 || options.concurrency > 50) {
+    throw new Error("--concurrency must be an integer between 1 and 50.");
+  }
+  if (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1000 || options.timeoutMs > 60000) {
+    throw new Error("--timeout-ms must be an integer between 1000 and 60000.");
+  }
+  if (!Number.isInteger(options.maxSuggestions) || options.maxSuggestions < 10 || options.maxSuggestions > 1000) {
+    throw new Error("--max-suggestions must be an integer between 10 and 1000.");
+  }
+  if (options.tld !== null && options.tld !== undefined) {
+    options.tld = options.tld.trim().toLowerCase().replace(/^\./, "");
+    if (!options.tld || !/^[a-z0-9-]{2,63}$/.test(options.tld)) {
+      throw new Error("--tld must be a valid TLD label such as 'md', 'com', or 'io'.");
+    }
+  }
+  if (options.server !== null && options.server !== undefined) {
+    options.server = options.server.trim().toLowerCase();
+    if (!options.server || /[^a-z0-9.-]/.test(options.server)) {
+      throw new Error("--server must be a valid host name such as 'whois.nic.md'.");
+    }
+  }
+
+  return options;
+}
+
+async function loadLabels(options) {
+  const values = [...options.labels];
+  if (options.input) {
+    const fullPath = path.resolve(options.input);
+    const file = await fs.readFile(fullPath, "utf8");
+    for (const rawLine of file.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      // Support comma-separated rows as well.
+      for (const cell of line.split(",")) {
+        const cleaned = cell.trim();
+        if (cleaned) {
+          values.push(cleaned);
+        }
+      }
+    }
+  }
+  return values;
+}
+
+function normalizeDomain(value, defaultTld) {
+  let v = value.trim().toLowerCase();
+  v = v.replace(/^https?:\/\//, "");
+  v = v.split("/")[0];
+  v = v.replace(/\.$/, "");
+  if (!v.includes(".") && defaultTld) {
+    v = `${v}.${defaultTld}`;
+  }
+  return v;
+}
+
+function normalizeLabel(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function isValidDomain(domain) {
+  return /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9-]{2,63}$/.test(domain);
+}
+
+function legalRisk(domain) {
+  const core = domain.slice(0, domain.lastIndexOf("."));
+  for (const keyword of TRADEMARK_KEYWORDS) {
+    if (core.includes(keyword)) {
+      return "high_tm_risk";
+    }
+  }
+  return "low";
+}
+
+function tokenizeSeeds(rawValues) {
+  const tokens = [];
+  for (const value of rawValues) {
+    let v = value.trim().toLowerCase();
+    if (!v) {
+      continue;
+    }
+    v = v.replace(/^https?:\/\//, "");
+    v = v.split("/")[0];
+    v = v.replace(/\.[a-z0-9.-]+$/i, "");
+    for (const token of v.split(/[^a-z0-9]+/)) {
+      if (!token || token.length < 2 || STOP_WORDS.has(token)) {
+        continue;
+      }
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}
+
+function brainstormCandidates(rawSeeds, maxSuggestions) {
+  const seedTokens = tokenizeSeeds(rawSeeds);
+  const seedPool = Array.from(new Set([...seedTokens, ...DEFAULT_STORM_SEEDS])).slice(0, 24);
+  const scored = new Map();
+
+  function add(label, story, bonus = 0) {
+    const normalized = normalizeLabel(label);
+    if (!normalized || normalized.length < 3 || normalized.length > 63) {
+      return;
+    }
+    if (!/^[a-z0-9]+$/.test(normalized)) {
+      return;
+    }
+    const lengthPenalty = normalized.length;
+    const score = 1000 - lengthPenalty * 7 + bonus;
+    const existing = scored.get(normalized);
+    if (!existing || score > existing.score) {
+      scored.set(normalized, { label: normalized, score, story });
+    }
+  }
+
+  for (const seed of seedPool) {
+    add(seed, "Keyword brand");
+    for (const suffix of STORM_SUFFIXES) {
+      add(`${seed}${suffix}`, "Keyword + product framing", seed.length < 8 ? 25 : 10);
+    }
+    for (const prefix of STORM_PREFIXES) {
+      add(`${prefix}${seed}`, "Platform + keyword framing", 10);
+    }
+  }
+
+  for (let i = 0; i < seedPool.length; i += 1) {
+    for (let j = i + 1; j < seedPool.length; j += 1) {
+      const a = seedPool[i];
+      const b = seedPool[j];
+      add(`${a}${b}`, "Two-keyword compound", 20);
+      add(`${b}${a}`, "Two-keyword compound", 20);
+      add(`${a}${b}hq`, "Company-style compound", 10);
+      add(`${a}${b}labs`, "Innovation-style compound", 8);
+    }
+  }
+
+  const sorted = Array.from(scored.values())
+    .sort((a, b) => b.score - a.score || a.label.localeCompare(b.label))
+    .slice(0, maxSuggestions);
+
+  return {
+    labels: sorted.map((item) => item.label),
+    storyByLabel: new Map(sorted.map((item) => [item.label, item.story])),
+    usedSeeds: seedTokens.length > 0 ? Array.from(new Set(seedTokens)) : DEFAULT_STORM_SEEDS,
+  };
+}
+
+function classifyWhois(raw) {
+  const text = raw.toLowerCase();
+  if (!text.trim()) {
+    return { status: "unknown", reason: "empty_whois_response" };
+  }
+  if (LOOKUP_ERROR_PATTERNS.some((p) => text.includes(p))) {
+    return { status: "unknown", reason: "whois_lookup_failed" };
+  }
+  if (RATE_LIMIT_PATTERNS.some((p) => text.includes(p))) {
+    return { status: "unknown", reason: "rate_limited_or_blocked" };
+  }
+  if (AVAILABILITY_PATTERNS.some((p) => text.includes(p))) {
+    return { status: "likely_available", reason: "availability_pattern_match" };
+  }
+  if (REGISTRATION_PATTERNS.some((p) => text.includes(p))) {
+    return { status: "registered", reason: "registration_pattern_match" };
+  }
+  return { status: "unknown", reason: "unrecognized_whois_format" };
+}
+
+function runWhois(domain, timeoutMs, server) {
+  return new Promise((resolve) => {
+    const args = server ? ["-h", server, domain] : [domain];
+    const child = spawn("whois", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+
+    const timer = setTimeout(() => {
+      if (!done) {
+        done = true;
+        child.kill("SIGKILL");
+        resolve({
+          domain,
+          status: "unknown",
+          reason: "whois_timeout",
+          raw: "",
+          error: `whois timed out after ${timeoutMs} ms`,
+        });
+      }
+    }, timeoutMs);
+
+    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({
+        domain,
+        status: "unknown",
+        reason: "whois_error",
+        raw: "",
+        error: err.message,
+      });
+    });
+
+    child.on("close", () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      const merged = [stdout, stderr].filter(Boolean).join("\n");
+      const classification = classifyWhois(merged);
+      const stderrText = stderr.trim();
+      resolve({
+        domain,
+        status: classification.status,
+        reason: classification.reason,
+        raw: merged.trim(),
+        error: classification.reason === "whois_lookup_failed" ? stderrText || "WHOIS lookup failed" : null,
+      });
+    });
+  });
+}
+
+async function mapLimit(items, limit, iterator) {
+  const results = new Array(items.length);
+  let index = 0;
+
+  async function worker() {
+    for (;;) {
+      const current = index;
+      index += 1;
+      if (current >= items.length) {
+        return;
+      }
+      results[current] = await iterator(items[current], current);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+function csvEscape(value) {
+  const text = String(value ?? "");
+  if (/[",\n]/.test(text)) {
+    return `"${text.replaceAll('"', '""')}"`;
+  }
+  return text;
+}
+
+async function maybeWriteCsv(results, outputPath) {
+  if (!outputPath) {
+    return;
+  }
+  const header = ["domain", "status", "reason", "legal_risk", "story", "error"];
+  const lines = [header.join(",")];
+  for (const row of results) {
+    lines.push(
+      [
+        row.domain,
+        row.status,
+        row.reason,
+        row.legalRisk,
+        row.story ?? "",
+        row.error ?? "",
+      ]
+        .map(csvEscape)
+        .join(","),
+    );
+  }
+  const absolute = path.resolve(outputPath);
+  await fs.writeFile(absolute, `${lines.join("\n")}\n`, "utf8");
+}
+
+function summarize(results) {
+  const counters = new Map();
+  for (const row of results) {
+    counters.set(row.status, (counters.get(row.status) ?? 0) + 1);
+  }
+  return {
+    likelyAvailable: counters.get("likely_available") ?? 0,
+    registered: counters.get("registered") ?? 0,
+    unknown: counters.get("unknown") ?? 0,
+  };
+}
+
+function snippet(raw) {
+  if (!raw) {
+    return "";
+  }
+  return raw.replace(/\s+/g, " ").slice(0, 120);
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  let rawLabels = await loadLabels(options);
+  let storyByLabel = new Map();
+
+  if (options.brainstorm) {
+    const storm = brainstormCandidates(rawLabels, options.maxSuggestions);
+    rawLabels = storm.labels;
+    storyByLabel = storm.storyByLabel;
+    console.error(
+      `Domainstorm: generated ${rawLabels.length} candidates from seeds [${storm.usedSeeds.join(", ")}]`,
+    );
+    console.error("Narrative: optimized for agent orchestration, tooling, control plane, and ops positioning.");
+  }
+
+  const domains = [];
+  const seen = new Set();
+
+  for (const raw of rawLabels) {
+    const domain = normalizeDomain(raw, options.tld);
+    if (!isValidDomain(domain)) {
+      console.error(`Skipping invalid label/domain: ${raw}`);
+      continue;
+    }
+    if (!seen.has(domain)) {
+      seen.add(domain);
+      domains.push(domain);
+    }
+  }
+
+  if (domains.length === 0) {
+    throw new Error("No valid domains found after normalization.");
+  }
+
+  const serverLabel = options.server ? `server=${options.server}` : "server=auto";
+  console.error(`Checking ${domains.length} domain(s) (${serverLabel}) with concurrency=${options.concurrency}`);
+
+  const checked = await mapLimit(domains, options.concurrency, async (domain) => {
+    const result = await runWhois(domain, options.timeoutMs, options.server);
+    const label = domain.slice(0, domain.lastIndexOf("."));
+    return {
+      ...result,
+      legalRisk: legalRisk(domain),
+      story: storyByLabel.get(label) ?? "",
+    };
+  });
+
+  const filtered = options.onlyAvailable
+    ? checked.filter((row) => row.status === "likely_available")
+    : checked;
+
+  for (const row of filtered) {
+    let line = `${row.domain}\t${row.status}\t${row.reason}\t${row.legalRisk}`;
+    if (row.story) {
+      line += `\tstory=${row.story}`;
+    }
+    if (row.error) {
+      line += `\terror=${row.error}`;
+    }
+    if (options.raw) {
+      line += `\t${snippet(row.raw)}`;
+    }
+    console.log(line);
+  }
+
+  await maybeWriteCsv(checked, options.output);
+
+  const counts = summarize(checked);
+  console.error(
+    `Summary: likely_available=${counts.likelyAvailable}, registered=${counts.registered}, unknown=${counts.unknown}`,
+  );
+  if (options.output) {
+    console.error(`CSV written: ${path.resolve(options.output)}`);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  printUsage();
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "domainstorm",
+  "version": "0.2.0",
+  "description": "Domainstorm CLI: brainstorm brandable names and check domain registration via WHOIS",
+  "type": "module",
+  "bin": {
+    "domainstorm": "check-md-domains.mjs",
+    "domain-check": "check-md-domains.mjs"
+  },
+  "files": [
+    "check-md-domains.mjs",
+    "agent-md-candidates.txt",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node check-md-domains.mjs --help"
+  },
+  "keywords": [
+    "domain",
+    "whois",
+    "cli",
+    "availability"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}