@promakeai/eslint 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,200 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { select, confirm } from "@inquirer/prompts";
+import pc from "picocolors";
+import { detectProjectType } from "../utils/detect.js";
+import { detectPackageManager, getInstallCommand, } from "../utils/pm.js";
+import { exec } from "../utils/exec.js";
+import { getEditorSettingsContent, getEslintConfigContent, getPrettierRcContent, getScripts, } from "../utils/templates.js";
+import { log } from "../utils/log.js";
+export async function init(options = {}) {
+    const cwd = process.cwd();
+    const yes = options.yes ?? false;
+    const allowPrettier = options.prettier ?? true;
+    console.log();
+    console.log(pc.bold("@promakeai/eslint") + " " + pc.dim("- ESLint + Prettier setup"));
+    console.log();
+    // Step 1: Verify package.json exists
+    const pkgPath = resolve(cwd, "package.json");
+    if (!existsSync(pkgPath)) {
+        log.error("No package.json found. Run this command from a project root.");
+        process.exit(1);
+    }
+    // Step 2: Detect or ask project type
+    let projectType;
+    if (options.projectType) {
+        const allowed = ["react-vite", "react-lib", "node"];
+        if (!allowed.includes(options.projectType)) {
+            log.error(`Invalid --project value: ${pc.bold(options.projectType)}. ` +
+                "Use react-vite, react-lib, or node.");
+            process.exit(1);
+        }
+        projectType = options.projectType;
+        log.info(`Project type: ${pc.bold(projectType)} (via --project)`);
+    }
+    else {
+        const detection = await detectProjectType(cwd);
+        if (detection.detected) {
+            log.info(`Detected: ${pc.bold(detection.detected)} (${detection.confidence})`);
+            const useDetected = yes
+                ? true
+                : await confirm({
+                    message: `Set up as ${pc.bold(detection.detected)} project?`,
+                    default: true,
+                });
+            projectType = useDetected ? detection.detected : await askProjectType();
+        }
+        else {
+            log.warn("Could not auto-detect project type.");
+            projectType = yes ? "node" : await askProjectType();
+            if (yes) {
+                log.info(`Defaulting to ${pc.bold(projectType)}`);
+            }
+        }
+    }
+    // Step 3: Detect package manager
+    const pm = detectPackageManager(cwd);
+    log.info(`Package manager: ${pc.bold(pm)}`);
+    // Step 4: Create eslint.config.mts
+    const eslintConfigPath = resolve(cwd, "eslint.config.mts");
+    if (existsSync(eslintConfigPath)) {
+        const overwrite = yes
+            ? true
+            : await confirm({
+                message: "eslint.config.mts already exists. Overwrite?",
+                default: false,
+            });
+        if (!overwrite) {
+            log.warn("Skipping eslint.config.mts");
+        }
+        else {
+            await writeFile(eslintConfigPath, getEslintConfigContent(projectType));
+            log.success("Created eslint.config.mts");
+        }
+    }
+    else {
+        await writeFile(eslintConfigPath, getEslintConfigContent(projectType));
+        log.success("Created eslint.config.mts");
+    }
+    // Step 5: Optionally create .prettierrc.json
+    const prettierRcPath = resolve(cwd, ".prettierrc.json");
+    if (allowPrettier) {
+        if (!existsSync(prettierRcPath)) {
+            const createPrettierRc = yes
+                ? true
+                : await confirm({
+                    message: "Create .prettierrc.json? (mirrors config defaults)",
+                    default: true,
+                });
+            if (createPrettierRc) {
+                await writeFile(prettierRcPath, getPrettierRcContent());
+                log.success("Created .prettierrc.json");
+            }
+        }
+        else {
+            log.info(".prettierrc.json already exists, skipping.");
+        }
+    }
+    else {
+        log.info("Skipping .prettierrc.json (--no-prettier)");
+    }
+    // Step 6: Optionally create editor settings for VSCode
+    const vscodeDir = resolve(cwd, ".vscode");
+    const vscodeSettingsPath = resolve(vscodeDir, "settings.json");
+    const ensureVscodeSettings = async () => {
+        try {
+            await mkdir(vscodeDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    };
+    if (!existsSync(vscodeSettingsPath)) {
+        await ensureVscodeSettings();
+        await writeFile(vscodeSettingsPath, getEditorSettingsContent());
+        log.success("Created .vscode/settings.json (format on save)");
+    }
+    else if (yes) {
+        await ensureVscodeSettings();
+        await writeFile(vscodeSettingsPath, getEditorSettingsContent());
+        log.success("Overwrote .vscode/settings.json with default editor preferences");
+    }
+    else {
+        log.info(".vscode/settings.json already exists, skipping editor config");
+    }
+    // Step 6: Update package.json scripts
+    const pkgRaw = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgRaw);
+    const newScripts = getScripts();
+    const existingScripts = pkg.scripts ?? {};
+    let scriptsAdded = 0;
+    for (const [key, value] of Object.entries(newScripts)) {
+        if (!(key in existingScripts)) {
+            existingScripts[key] = value;
+            scriptsAdded++;
+        }
+    }
+    if (scriptsAdded > 0) {
+        pkg.scripts = existingScripts;
+        await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        log.success(`Added ${scriptsAdded} script(s) to package.json`);
+    }
+    else {
+        log.info("All lint/format scripts already exist in package.json");
+    }
+    // Step 7: Install dependencies
+    const depsToInstall = getDependencies();
+    console.log();
+    log.step("Installing dependencies...");
+    log.info(pc.dim(depsToInstall.join(", ")));
+    const installCmd = getInstallCommand(pm, depsToInstall, true);
+    log.info(pc.dim(`$ ${installCmd}`));
+    const result = await exec(installCmd, cwd);
+    if (result.code !== 0) {
+        log.error("Installation failed:");
+        console.error(result.stderr);
+        process.exit(1);
+    }
+    log.success("Dependencies installed");
+    // Done
+    console.log();
+    log.success(pc.bold("ESLint + Prettier configured!"));
+    console.log();
+    const runPrefix = pm === "npm" ? "npm run" : pm;
+    console.log(`  ${pc.dim("$")} ${runPrefix} lint`);
+    console.log(`  ${pc.dim("$")} ${runPrefix} lint:fix`);
+    console.log(`  ${pc.dim("$")} ${runPrefix} format`);
+    console.log();
+}
+async function askProjectType() {
+    return select({
+        message: "What type of project is this?",
+        choices: [
+            {
+                name: "React + Vite (SPA)",
+                value: "react-vite",
+                description: "Browser app with React and Vite",
+            },
+            {
+                name: "React Library",
+                value: "react-lib",
+                description: "Publishable React component library",
+            },
+            {
+                name: "Node.js / CLI",
+                value: "node",
+                description: "Server, API, CLI tool, or library",
+            },
+        ],
+    });
+}
+function getDependencies() {
+    return [
+        "@promakeai/eslint-config",
+        "eslint",
+        "prettier",
+        "typescript",
+        "jiti",
+    ];
+}

package/dist/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { init } from "./commands/init.js";
+import pc from "picocolors";
+const args = process.argv.slice(2);
+const command = args[0];
+function parseInitOptions(argv) {
+    const options = {
+        yes: false,
+        prettier: true,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+        }
+        else if (arg === "--no-prettier") {
+            options.prettier = false;
+        }
+        else if (arg === "--project" || arg === "-p") {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error("Missing value for --project");
+            }
+            options.projectType = value;
+            i++;
+        }
+    }
+    return options;
+}
+async function main() {
+    if (!command || command === "init") {
+        const opts = parseInitOptions(args.slice(command ? 1 : 0));
+        await init(opts);
+    }
+    else if (command === "--help" || command === "-h") {
+        printHelp();
+    }
+    else if (command === "--version" || command === "-v") {
+        console.log("0.1.0");
+    }
+    else {
+        console.error(pc.red(`Unknown command: ${command}`));
+        printHelp();
+        process.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`
+${pc.bold("@promakeai/eslint")} - ESLint + Prettier scaffolding tool
+
+${pc.bold("Usage:")}
+  npx @promakeai/eslint init [options]    Set up ESLint + Prettier in your project
+
+${pc.bold("Options:")}
+  -y, --yes            Accept all prompts (overwrite files, create .prettierrc)
+  -p, --project <type> One of: react-vite | react-lib | node
+  --no-prettier        Skip creating .prettierrc.json
+  -h, --help       Show this help message
+  -v, --version    Show version number
+`);
+}
+main().catch((err) => {
+    console.error(pc.red("Error:"), err.message);
+    process.exit(1);
+});

package/dist/utils/detect.js

@@ -0,0 +1,39 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export async function detectProjectType(cwd) {
+    const viteConfigExists = existsSync(resolve(cwd, "vite.config.ts")) ||
+        existsSync(resolve(cwd, "vite.config.js")) ||
+        existsSync(resolve(cwd, "vite.config.mts"));
+    let pkg = {};
+    try {
+        const raw = await readFile(resolve(cwd, "package.json"), "utf-8");
+        pkg = JSON.parse(raw);
+    }
+    catch {
+        return { detected: null, confidence: "No package.json found" };
+    }
+    const allDeps = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+    };
+    const hasReact = "react" in allDeps;
+    const hasVite = "vite" in allDeps;
+    const hasNext = "next" in allDeps;
+    if (hasReact && (hasVite || viteConfigExists)) {
+        return { detected: "react-vite", confidence: "Found react + vite" };
+    }
+    if (hasReact && !hasVite && !hasNext) {
+        return {
+            detected: "react-lib",
+            confidence: "Found react without vite/next",
+        };
+    }
+    if (!hasReact) {
+        return {
+            detected: "node",
+            confidence: "No browser framework detected",
+        };
+    }
+    return { detected: null, confidence: "Could not determine project type" };
+}

package/dist/utils/exec.js

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+export function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}

package/dist/utils/log.js

@@ -0,0 +1,8 @@
+import pc from "picocolors";
+export const log = {
+    info: (msg) => console.log(pc.cyan("i"), msg),
+    success: (msg) => console.log(pc.green("\u2713"), msg),
+    warn: (msg) => console.log(pc.yellow("!"), msg),
+    error: (msg) => console.error(pc.red("\u2717"), msg),
+    step: (msg) => console.log(pc.bold(pc.blue(">")), msg),
+};

package/dist/utils/pm.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+export function detectPackageManager(cwd) {
+    if (existsSync(resolve(cwd, "bun.lock")) ||
+        existsSync(resolve(cwd, "bun.lockb"))) {
+        return "bun";
+    }
+    if (existsSync(resolve(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(resolve(cwd, "yarn.lock"))) {
+        return "yarn";
+    }
+    return "npm";
+}
+export function getInstallCommand(pm, packages, dev) {
+    const pkgs = packages.join(" ");
+    switch (pm) {
+        case "bun":
+            return `bun add${dev ? " -D" : ""} ${pkgs}`;
+        case "pnpm":
+            return `pnpm add${dev ? " -D" : ""} ${pkgs}`;
+        case "yarn":
+            return `yarn add${dev ? " -D" : ""} ${pkgs}`;
+        case "npm":
+        default:
+            return `npm install${dev ? " --save-dev" : ""} ${pkgs}`;
+    }
+}

package/dist/utils/templates.js

@@ -0,0 +1,45 @@
+export function getEslintConfigContent(projectType) {
+    switch (projectType) {
+        case "react-vite":
+        case "react-lib":
+            return `import config from "@promakeai/eslint-config/react";
+
+export default config;
+`;
+        case "node":
+            return `import config from "@promakeai/eslint-config/node";
+
+export default config;
+`;
+    }
+}
+export function getPrettierRcContent() {
+    return (JSON.stringify({
+        semi: true,
+        singleQuote: false,
+        tabWidth: 2,
+        trailingComma: "all",
+        printWidth: 80,
+        bracketSpacing: true,
+        arrowParens: "always",
+        endOfLine: "auto",
+    }, null, 2) + "\n");
+}
+export function getScripts() {
+    return {
+        lint: "eslint .",
+        "lint:fix": "eslint . --fix",
+        format: "prettier --write .",
+        "format:check": "prettier --check .",
+    };
+}
+export function getEditorSettingsContent() {
+    return JSON.stringify({
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.codeActionsOnSave": {
+            "source.fixAll.eslint": true,
+        },
+        "files.autoSave": "off",
+    }, null, 2) + "\n";
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@promakeai/eslint",
+  "version": "0.1.0",
+  "description": "CLI to scaffold ESLint + Prettier with @promakeai/eslint-config",
+  "type": "module",
+  "bin": {
+    "@promakeai/eslint": "./dist/index.js",
+    "promake-eslint": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "dev": "bun run src/index.ts",
+    "pack": "bun run clean && bun run build && npm pack --dry-run",
+    "publish": "bun run clean && bun run build && npm publish --access public",
+    "release": "npm run publish",
+    "prepublishOnly": "bun run clean && bun run build"
+  },
+  "keywords": [
+    "eslint",
+    "prettier",
+    "cli",
+    "scaffolding",
+    "typescript"
+  ],
+  "author": "Promake",
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}