domainstorm 0.2.6 → 0.3.1

package/README.md

@@ -2,12 +2,10 @@
 
 [![npm version](https://img.shields.io/npm/v/domainstorm)](https://www.npmjs.com/package/domainstorm)
 [![npm downloads](https://img.shields.io/npm/dm/domainstorm)](https://www.npmjs.com/package/domainstorm)
-[![CI](https://img.shields.io/github/actions/workflow/status/tanishqsh/domain-cli/npm-publish.yml)](https://github.com/tanishqsh/domain-cli/actions/workflows/npm-publish.yml)
 
 Domainstorm is the fastest way to go from "we need a name" to "these are the domains we can buy now."
 
 It is built for AI and agent products where naming cycles happen fast and every good domain disappears quickly.
-
 ## Why Domainstorm
 
 - One command for ideation and availability checks
@@ -78,6 +76,18 @@ Compatibility alias:
 domain-check --help
 ```
 
+## Zero Install — Just `npx`
+
+Agents don't need to install anything globally. Domainstorm works out of the box with `npx`:
+
+```bash
+npx domainstorm --brainstorm "agent runtime" --tld com --only-available --table
+```
+
+No setup, no config, no API keys. One command and the agent has domain availability data. This makes it trivial to add to any agent's tool chain — just shell out to `npx domainstorm` and parse the output.
+
+Works with Claude Code, Codex, OpenClaw, Cursor, and any agent that can run shell commands.
+
 ## Example Output
 
 ```txt
@@ -112,6 +122,24 @@ Output columns:
 - `--timeout-ms <n>`
 - `--raw`
 
+## OpenClaw / AI Agent Skill
+
+Domainstorm ships as an [OpenClaw](https://openclaw.ai) skill. Install it with a single `npx` command — no global install needed:
+
+```bash
+npx domainstorm --install-skill
+```
+
+This launches an interactive installer that lets you pick where to install the skill (Claude Code, OpenClaw, Cursor, or a custom path). Once installed, your agent will automatically use Domainstorm when you ask it to brainstorm or check domains.
+
+You can also print the skill file to stdout for manual setup:
+
+```bash
+npx domainstorm --skill
+```
+
+Works with any agent that supports OpenClaw skills — Claude, Codex, Cursor, and others.
+
 ## Notes
 
 - WHOIS formats vary by registry; treat `likely_available` as a pre-check, not final registrar checkout.

package/check-domains.mjs

@@ -101,6 +101,228 @@ const TRADEMARK_KEYWORDS = [
   "spacex",
 ];
 
+import { createInterface } from "node:readline";
+import { homedir } from "node:os";
+
+const SKILL_DIRS = [
+  { name: "OpenClaw", path: path.join(homedir(), ".openclaw", "workspace", "skills") },
+  { name: "OpenClaw (global)", path: path.join(homedir(), ".openclaw", "skills") },
+  { name: "Claude Code", path: path.join(homedir(), ".claude", "skills") },
+  { name: "Cursor", path: path.join(homedir(), ".cursor", "skills") },
+  { name: "Codex", path: path.join(homedir(), ".codex", "skills") },
+  { name: "Local ./skills", path: path.resolve("skills") },
+];
+
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+const WHITE = "\x1b[37m";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const CLEAR_LINE = "\x1b[2K";
+const UP = (n) => `\x1b[${n}A`;
+
+function multiSelect(items) {
+  return new Promise((resolve) => {
+    const selected = new Set();
+    let cursor = 0;
+    const stdin = process.stdin;
+    const out = process.stdout;
+
+    // Pre-select detected items
+    items.forEach((item, i) => {
+      if (item.exists) selected.add(i);
+    });
+
+    function render() {
+      let output = "";
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const isSelected = selected.has(i);
+        const isCursor = i === cursor;
+        const checkbox = isSelected ? `${GREEN}◉${RESET}` : `${DIM}○${RESET}`;
+        const pointer = isCursor ? `${CYAN}❯${RESET} ` : "  ";
+        const label = isCursor ? `${WHITE}${BOLD}${item.name}${RESET}` : `${WHITE}${item.name}${RESET}`;
+        const pathStr = `${DIM}${item.path}${RESET}`;
+        const badge = item.exists ? ` ${GREEN}● found${RESET}` : "";
+        output += `${CLEAR_LINE}${pointer}${checkbox} ${label}  ${pathStr}${badge}\n`;
+      }
+      output += `${CLEAR_LINE}\n`;
+      output += `${CLEAR_LINE}${DIM}↑↓ navigate  ⎵ select  ↵ confirm  a toggle all  q cancel${RESET}`;
+      out.write(output);
+    }
+
+    function clearRender() {
+      const totalLines = items.length + 2;
+      out.write(UP(totalLines) + "\r");
+    }
+
+    out.write(`\n${BOLD}📦 Where do you want to install?${RESET}\n\n`);
+    out.write(HIDE_CURSOR);
+    render();
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onKey);
+      out.write(SHOW_CURSOR + "\n");
+    }
+
+    function onKey(key) {
+      // Ctrl+C
+      if (key === "\x03") {
+        cleanup();
+        process.exit(0);
+      }
+      // q / Escape
+      if (key === "q" || key === "\x1b" && key.length === 1) {
+        cleanup();
+        resolve([]);
+        return;
+      }
+      // Enter
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(items.filter((_, i) => selected.has(i)));
+        return;
+      }
+      // Space
+      if (key === " ") {
+        if (selected.has(cursor)) {
+          selected.delete(cursor);
+        } else {
+          selected.add(cursor);
+        }
+      }
+      // a — toggle all
+      if (key === "a") {
+        if (selected.size === items.length) {
+          selected.clear();
+        } else {
+          items.forEach((_, i) => selected.add(i));
+        }
+      }
+      // Up arrow
+      if (key === "\x1b[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+      }
+      // Down arrow
+      if (key === "\x1b[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+      }
+      clearRender();
+      render();
+    }
+
+    stdin.on("data", onKey);
+  });
+}
+
+async function installSkill() {
+  const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+  const skillSrc = path.join(scriptDir, "SKILL.md");
+
+  try {
+    await fs.access(skillSrc);
+  } catch {
+    console.error("Error: SKILL.md not found in domainstorm package. Try updating: npm i -g domainstorm@latest");
+    process.exit(1);
+  }
+
+  console.log(`\n${BOLD}${CYAN}domainstorm${RESET} ${DIM}— skill installer${RESET}\n`);
+
+  const items = [];
+  for (const dir of SKILL_DIRS) {
+    let exists = false;
+    try {
+      await fs.access(dir.path);
+      exists = true;
+    } catch {}
+    items.push({ ...dir, exists });
+  }
+
+  let selections;
+
+  if (process.stdin.isTTY) {
+    selections = await multiSelect(items);
+  } else {
+    // Fallback for non-TTY (piped input, CI, agents)
+    console.log(`${BOLD}📦 Where do you want to install?${RESET}\n`);
+    items.forEach((item, i) => {
+      const badge = item.exists ? ` ${GREEN}● found${RESET}` : "";
+      console.log(`  ${i + 1}. ${item.name}  ${DIM}${item.path}${RESET}${badge}`);
+    });
+    console.log(`  ${items.length + 1}. Enter custom path\n`);
+
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(`Select (1-${items.length + 1}, comma-separated): `, resolve);
+    });
+    rl.close();
+
+    const indices = answer.split(",").map((s) => Number(s.trim()) - 1).filter((i) => i >= 0 && i < items.length);
+    selections = indices.map((i) => items[i]);
+  }
+
+  if (selections.length === 0) {
+    console.log(`${DIM}No directories selected. Exiting.${RESET}`);
+    process.exit(0);
+  }
+
+  console.log("");
+  const skillContent = await fs.readFile(skillSrc, "utf8");
+
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  const out = process.stdout;
+
+  for (const item of selections) {
+    const destDir = path.join(item.path, "domainstorm");
+    const destFile = path.join(destDir, "SKILL.md");
+
+    // Spinner
+    let frameIdx = 0;
+    const spinner = setInterval(() => {
+      out.write(`\r${CLEAR_LINE}  ${CYAN}${frames[frameIdx]}${RESET} Installing to ${BOLD}${item.name}${RESET}${DIM}...${RESET}`);
+      frameIdx = (frameIdx + 1) % frames.length;
+    }, 80);
+
+    try {
+      await fs.mkdir(destDir, { recursive: true });
+      await fs.writeFile(destFile, skillContent, "utf8");
+      // Small delay so spinner is visible
+      await new Promise((r) => setTimeout(r, 400));
+      clearInterval(spinner);
+      out.write(`\r${CLEAR_LINE}  ${GREEN}✓${RESET} ${BOLD}${item.name}${RESET} ${DIM}→ ${destFile}${RESET}\n`);
+    } catch (err) {
+      clearInterval(spinner);
+      out.write(`\r${CLEAR_LINE}  ${YELLOW}✗${RESET} ${BOLD}${item.name}${RESET} ${DIM}— ${err.message}${RESET}\n`);
+    }
+  }
+
+  console.log("");
+  console.log(`  ${GREEN}${BOLD}✨ Done!${RESET} Your agent can now discover domainstorm as a skill.`);
+  console.log(`  ${DIM}Restart your agent or start a new session to pick it up.${RESET}\n`);
+}
+
+async function printSkill() {
+  const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+  const skillSrc = path.join(scriptDir, "SKILL.md");
+  try {
+    const content = await fs.readFile(skillSrc, "utf8");
+    console.log(content);
+  } catch {
+    console.error("Error: SKILL.md not found in domainstorm package.");
+    process.exit(1);
+  }
+}
+
 function printUsage() {
   console.log(
     [
@@ -123,6 +345,8 @@ function printUsage() {
       "  --plain                Emit machine-friendly TSV output",
       "  --only-available       Print only likely available domains",
       "  --raw                  Include WHOIS snippet in console output",
+      "  --install-skill        Install SKILL.md to your agent's skill directory",
+      "  --skill                Print SKILL.md to stdout",
       "  --help                 Show this help",
       "",
       "Notes:",
@@ -135,7 +359,7 @@ function printUsage() {
   );
 }
 
-function parseArgs(argv) {
+async function parseArgs(argv) {
   const options = {
     input: null,
     output: null,
@@ -201,6 +425,12 @@ function parseArgs(argv) {
       case "--raw":
         options.raw = true;
         break;
+      case "--install-skill":
+        await installSkill();
+        process.exit(0);
+      case "--skill":
+        await printSkill();
+        process.exit(0);
       case "--help":
       case "-h":
         printUsage();
@@ -894,7 +1124,7 @@ function shouldAutoThrottleWhois(domains) {
 }
 
 async function main() {
-  const options = parseArgs(process.argv.slice(2));
+  const options = await parseArgs(process.argv.slice(2));
   let rawLabels = await loadLabels(options);
   let storyByLabel = new Map();
 

package/package.json

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