is-tty 1.0.0

package/README.md

@@ -0,0 +1,63 @@
+# is-tty
+
+> CLI tool and API to detect whether the current environment is interactive (TTY).
+
+Useful for determining if your script can safely prompt users for input, or if it should fall back to non-interactive mode (e.g., in CI environments).
+
+## Installation
+
+```bash
+# With bun
+bun add -d is-tty
+
+# With npm
+npm install -D is-tty
+
+# Global install for CLI usage
+npm install -g is-tty
+```
+
+## CLI Usage
+
+```bash
+# Exit code 0 if interactive, 1 if non-interactive
+if is-tty; then
+  echo "✅ Interactive terminal"
+else
+  echo "❌ Non-interactive (e.g., CI, pipe, dumb terminal)"
+fi
+
+# Use it in package.json scripts
+{
+  "scripts": {
+    "postinstall": "is-tty && npx @lvxiaohui/ai-rule || echo 'Skipping in non-interactive env'"
+  }
+}
+```
+
+## API Usage
+
+```javascript
+const isTTY = require('is-tty');
+
+if (isTTY()) {
+  console.log('✅ Interactive terminal');
+  // Prompt user for input, run interactive commands, etc.
+} else {
+  console.log('❌ Non-interactive environment');
+  // Fallback to silent/default mode
+}
+```
+
+## Detection Logic
+
+| Condition | Interactive? |
+| :--- | :---: |
+| `process.stdout.isTTY === true` | ✅ |
+| `CI=true` or `CI=1` | ❌ |
+| `TERM=dumb` | ❌ |
+| Otherwise | ✅ |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "is-tty",
+  "version": "1.0.0",
+  "description": "CLI tool to detect whether the current environment is interactive (TTY).",
+  "bin": {
+    "is-tty": "./src/cli.js"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "bun test",
+    "prepublishOnly": "bun test"
+  },
+  "keywords": [
+    "tty",
+    "interactive",
+    "cli",
+    "terminal",
+    "stdout",
+    "isatty",
+    "ci"
+  ],
+  "author": "rainmanhhh",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const isTTY = require('./index.js');
+
+const interactive = isTTY();
+
+if (process.argv.includes('--json') || process.argv.includes('-j')) {
+  process.stdout.write(JSON.stringify({ interactive }) + '\n');
+} else if (process.argv.includes('--verbose') || process.argv.includes('-v')) {
+  process.stdout.write(
+    `stdout.isTTY: ${process.stdout.isTTY}\n` +
+    `stdin.isTTY:  ${process.stdin.isTTY}\n` +
+    `stderr.isTTY: ${process.stderr.isTTY}\n` +
+    `CI:           ${JSON.stringify(process.env.CI)}\n` +
+    `TERM:         ${JSON.stringify(process.env.TERM)}\n` +
+    `interactive:  ${interactive}\n`
+  );
+}
+
+process.exit(interactive ? 0 : 1);

package/src/index.js

@@ -0,0 +1,39 @@
+/**
+ * Check if the current environment is interactive (TTY).
+ *
+ * Detection logic:
+ * - `process.stdout.isTTY` is `true` — interactive
+ * - `CI` env var is set to a truthy value — non-interactive (e.g., GitHub Actions, GitLab CI)
+ * - `TERM` env var is `dumb` — non-interactive
+ * - Otherwise — interactive
+ *
+ * @returns {boolean} `true` if the environment is interactive, `false` otherwise.
+ */
+function isTTY() {
+  // Direct TTY check on stdout (most reliable)
+  if (process.stdout.isTTY) {
+    return true;
+  }
+
+  // CI environments are non-interactive by definition
+  const ci = process.env.CI;
+  if (ci !== undefined && ci !== '' && ci !== '0' && ci !== 'false') {
+    return false;
+  }
+
+  // Dumb terminals (e.g., Emacs, some CI runners) are non-interactive
+  if (process.env.TERM === 'dumb') {
+    return false;
+  }
+
+  // Fallback: if neither CI nor dumb terminal, check stdin/stderr
+  if (process.stdin.isTTY || process.stderr.isTTY) {
+    return true;
+  }
+
+  // If all streams are non-TTY and no explicit CI/TERM signal, assume non-interactive
+  return false;
+}
+
+module.exports = isTTY;
+module.exports.default = isTTY;