@rohilaharsh/react-kit 0.1.1

package/README.md

@@ -0,0 +1,87 @@
+# @rohilaharsh/react-kit
+
+A small CLI that installs a React-related toolkit into an existing Node/React project.
+
+It detects your package manager from lockfiles and runs the appropriate install command for:
+
+- `singleton-injection`
+- `context-scoped-state`
+- `axios`
+- `rxjs`
+
+## Installation & usage
+
+You do **not** install this package as a dependency of your app. Instead, run it via your preferred runner:
+
+```bash
+bunx @rohilaharsh/react-kit init
+# or
+npx @rohilaharsh/react-kit init
+# or
+pnpm dlx @rohilaharsh/react-kit init
+# or
+yarn dlx @rohilaharsh/react-kit init
+```
+
+Run the command **inside an existing project** that already has a `package.json`.
+
+## What it does
+
+1. Verifies there is a `package.json` in the current working directory.
+2. Detects your package manager in this order:
+   - `bun.lockb` → Bun
+   - `pnpm-lock.yaml` → pnpm
+   - `yarn.lock` → Yarn
+   - `package-lock.json` → npm
+   - Otherwise, falls back to the `packageManager` field in `package.json` if present.
+   - If nothing else matches, defaults to npm.
+3. Runs the matching install command to add:
+   - `singleton-injection`
+   - `context-scoped-state`
+   - `axios`
+   - `rxjs`
+
+## Local development (with Bun)
+
+This repo is built and tested using [Bun](https://bun.sh).
+
+Install dependencies:
+
+```bash
+bun install
+```
+
+Build the CLI:
+
+```bash
+bun run build
+```
+
+Run tests:
+
+```bash
+bun test
+```
+
+## Publishing to npm (using Bun)
+
+Before publishing, make sure you are logged in with npm:
+
+```bash
+npm login
+```
+
+Then use the provided scripts:
+
+```bash
+# Bump version (patch/minor/major) and create a git tag, per npm conventions
+npm version patch
+
+# Or use the generic script wired through Bun
+bun run version
+
+# Build and publish
+bun run publish
+```
+
+The `prepublishOnly` hook ensures that the TypeScript sources are compiled to `dist/` before `npm publish` runs.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("./commands/init");
+async function main() {
+    const [, , command, ...rest] = process.argv;
+    switch (command) {
+        case "init":
+            await (0, init_1.runInit)(rest);
+            break;
+        case "--help":
+        case "-h":
+        default:
+            printHelp();
+            process.exit(0);
+    }
+}
+function printHelp() {
+    console.log(`
+@rohilaharsh/react-kit
+
+Usage:
+  bunx @rohilaharsh/react-kit init
+  npx @rohilaharsh/react-kit init
+  pnpm dlx @rohilaharsh/react-kit init
+  yarn dlx @rohilaharsh/react-kit init
+
+Commands:
+  init   Install React-related toolkit dependencies into the current project.
+`);
+}
+main().catch((error) => {
+    console.error("[react-kit] Unexpected error:", error);
+    process.exit(1);
+});

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(_args: string[]): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const detectPackageManager_1 = require("../detectPackageManager");
+const installDeps_1 = require("../installDeps");
+const REACT_DEPS = [
+    "singleton-injection",
+    "context-scoped-state",
+    "axios",
+    "rxjs",
+];
+async function runInit(_args) {
+    const cwd = process.cwd();
+    const pkgJsonPath = path_1.default.join(cwd, "package.json");
+    if (!fs_1.default.existsSync(pkgJsonPath)) {
+        console.error("[react-kit] No package.json found in the current directory. Please run this inside a Node/React project.");
+        process.exit(1);
+    }
+    console.log("[react-kit] Detected package.json in current directory.");
+    const { manager, source } = (0, detectPackageManager_1.detectPackageManager)(cwd);
+    console.log(`[react-kit] Detected package manager: ${manager} (via ${source}).`);
+    console.log(`[react-kit] Installing dependencies: ${REACT_DEPS.join(", ")}...`);
+    try {
+        await (0, installDeps_1.installDeps)({
+            manager,
+            deps: REACT_DEPS,
+            cwd,
+        });
+        console.log("[react-kit] Successfully installed singleton-injection, context-scoped-state, axios, rxjs.");
+        console.log("[react-kit] You can now wire these into your React app (e.g., providers, hooks, data fetching).");
+    }
+    catch (error) {
+        console.error("[react-kit] Failed to install dependencies.");
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        else {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}

package/dist/detectPackageManager.d.ts

@@ -0,0 +1,6 @@
+export type PackageManager = "bun" | "pnpm" | "yarn" | "npm";
+export interface DetectResult {
+    manager: PackageManager;
+    source: "lockfile" | "packageManager-field" | "default";
+}
+export declare function detectPackageManager(cwd?: string): DetectResult;

package/dist/detectPackageManager.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPackageManager = detectPackageManager;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function fileExistsSync(filePath) {
+    try {
+        fs_1.default.accessSync(filePath, fs_1.default.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function detectPackageManager(cwd = process.cwd()) {
+    const lockfiles = {
+        bun: path_1.default.join(cwd, "bun.lockb"),
+        pnpm: path_1.default.join(cwd, "pnpm-lock.yaml"),
+        yarn: path_1.default.join(cwd, "yarn.lock"),
+        npm: path_1.default.join(cwd, "package-lock.json"),
+    };
+    if (fileExistsSync(lockfiles.bun)) {
+        return { manager: "bun", source: "lockfile" };
+    }
+    if (fileExistsSync(lockfiles.pnpm)) {
+        return { manager: "pnpm", source: "lockfile" };
+    }
+    if (fileExistsSync(lockfiles.yarn)) {
+        return { manager: "yarn", source: "lockfile" };
+    }
+    if (fileExistsSync(lockfiles.npm)) {
+        return { manager: "npm", source: "lockfile" };
+    }
+    // Fallback: try package.json "packageManager" field
+    const pkgJsonPath = path_1.default.join(cwd, "package.json");
+    if (fileExistsSync(pkgJsonPath)) {
+        try {
+            const pkgRaw = fs_1.default.readFileSync(pkgJsonPath, "utf8");
+            const pkg = JSON.parse(pkgRaw);
+            if (pkg.packageManager?.startsWith("bun")) {
+                return { manager: "bun", source: "packageManager-field" };
+            }
+            if (pkg.packageManager?.startsWith("pnpm")) {
+                return { manager: "pnpm", source: "packageManager-field" };
+            }
+            if (pkg.packageManager?.startsWith("yarn")) {
+                return { manager: "yarn", source: "packageManager-field" };
+            }
+            if (pkg.packageManager?.startsWith("npm")) {
+                return { manager: "npm", source: "packageManager-field" };
+            }
+        }
+        catch {
+            // ignore parse errors and fall through
+        }
+    }
+    // Default to npm if nothing else is detected.
+    return { manager: "npm", source: "default" };
+}

package/dist/installDeps.d.ts

@@ -0,0 +1,12 @@
+import { PackageManager } from "./detectPackageManager";
+export interface InstallDepsOptions {
+    manager: PackageManager;
+    deps: string[];
+    isDev?: boolean;
+    cwd?: string;
+}
+export declare function buildInstallCommand(options: InstallDepsOptions): {
+    command: string;
+    args: string[];
+};
+export declare function installDeps(options: InstallDepsOptions): Promise<void>;

package/dist/installDeps.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInstallCommand = buildInstallCommand;
+exports.installDeps = installDeps;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+function buildInstallCommand(options) {
+    const { manager, deps, isDev } = options;
+    switch (manager) {
+        case "npm":
+            return {
+                command: "npm",
+                args: ["install", ...(isDev ? ["--save-dev"] : []), ...deps],
+            };
+        case "yarn":
+            return {
+                command: "yarn",
+                args: ["add", ...(isDev ? ["-D"] : []), ...deps],
+            };
+        case "pnpm":
+            return {
+                command: "pnpm",
+                args: ["add", ...(isDev ? ["-D"] : []), ...deps],
+            };
+        case "bun":
+            return {
+                command: "bun",
+                args: ["add", ...(isDev ? ["-d"] : []), ...deps],
+            };
+        default: {
+            const exhaustiveCheck = manager;
+            throw new Error(`Unsupported package manager: ${exhaustiveCheck}`);
+        }
+    }
+}
+function installDeps(options) {
+    const { command, args } = buildInstallCommand(options);
+    const cwd = options.cwd ?? process.cwd();
+    return new Promise((resolve, reject) => {
+        console.log(`[react-kit] Running: ${command} ${args.join(" ")} (cwd: ${path_1.default.resolve(cwd)})`);
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (error) => {
+            console.error("[react-kit] Failed to start install process:", error);
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            if (signal) {
+                const err = new Error(`[react-kit] Install process was terminated with signal ${signal}`);
+                reject(err);
+                return;
+            }
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const err = new Error(`[react-kit] Install command exited with code ${code}`);
+                reject(err);
+            }
+        });
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@rohilaharsh/react-kit",
+  "version": "0.1.1",
+  "description": "CLI to initialize a React-related toolkit by installing singleton-injection, context-scoped-state, axios, and rxjs using the detected package manager.",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/cli.js",
+  "bin": {
+    "react-kit": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run tsc -p tsconfig.json",
+    "test": "bun test",
+    "version": "npm version",
+    "prepublishOnly": "bun run build",
+    "publish": "bun run build && npm publish"
+  },
+  "keywords": [
+    "react",
+    "cli",
+    "bun",
+    "toolkit",
+    "singleton-injection",
+    "context-scoped-state",
+    "axios",
+    "rxjs"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}