domainstorm 0.2.5 → 0.3.0

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
@@ -70,7 +68,6 @@ Use Domainstorm when your coding/research agent needs to propose names and valid
 - Deterministic CLI output
 - Works with shell pipelines
 - No external AI API keys required
-- Easy to trigger in CI on release or branch workflows
 - No seed ideas? Ask your agent of choice (Codex, Claude, etc.) for seed phrases and pass them to `--brainstorm`
 
 Compatibility alias:
@@ -79,22 +76,17 @@ Compatibility alias:
 domain-check --help
 ```
 
-## Local Dev Test (npm)
+## Zero Install — Just `npx`
 
-Run the current repo version without publishing:
+Agents don't need to install anything globally. Domainstorm works out of the box with `npx`:
 
 ```bash
-npm run check
-npm link
-domainstorm --help
-domainstorm broker.md --table
+npx domainstorm --brainstorm "agent runtime" --tld com --only-available --table
 ```
 
-Remove local link when done:
+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.
 
-```bash
-npm unlink -g domainstorm
-```
+Works with Claude Code, Codex, OpenClaw, Cursor, and any agent that can run shell commands.
 
 ## Example Output
 
@@ -130,6 +122,19 @@ Output columns:
 - `--timeout-ms <n>`
 - `--raw`
 
+## OpenClaw / AI Agent Skill
+
+Domainstorm ships as an [OpenClaw](https://openclaw.ai) skill. Install it and any OpenClaw-powered agent will automatically use Domainstorm when you ask it to brainstorm or check domains.
+
+```bash
+# Install the skill (from ClaHub or local)
+openclaw skill install domainstorm
+```
+
+Or drop the [`SKILL.md`](https://github.com/tanishqsh/domain-cli/blob/main/skill/SKILL.md) into your `~/.openclaw/workspace/skills/domainstorm/` directory manually.
+
+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.5",
+  "version": "0.3.0",
   "description": "Brainstorm and check domain names in one command.",
   "repository": {
     "type": "git",