@dvukovic/style-guide 0.5.2 → 0.7.0

package/README.md

@@ -1,50 +1,61 @@
 # @dvukovic/style-guide
 
-Personal style guide with ESLint, Prettier, and other code quality tools
+Personal style guide with ESLint, Prettier, Stylelint, and CSpell configurations.
 
-## Installation
+## Quick Start
 
 ```bash
-yarn add -D @dvukovic/style-guide eslint prettier cspell stylelint
+npx @dvukovic/style-guide init
 ```
 
-## ESLint Configuration
+This interactive CLI will:
 
-### Basic Usage
+- Let you select which tools to configure (ESLint, Prettier, Stylelint, CSpell)
+- Ask about your project setup (TypeScript, React/Next.js, testing frameworks)
+- Install required dependencies
+- Generate configuration files
 
-Create an `eslint.config.js` file in your project root:
+## Manual Installation
+
+```bash
+yarn add -D @dvukovic/style-guide eslint prettier stylelint cspell knip
+```
+
+## ESLint
+
+Create `eslint.config.js`:
 
 ```js
 import { customDefineConfig, core, typescript } from "@dvukovic/style-guide/eslint"
 
-export default customDefineConfig(["dist/**", "build/**"], [core(), typescript()])
+export default customDefineConfig(["dist", "build"], [core(), typescript()])
 ```
 
 ### Available Configs
 
-Each config is a factory function that returns ESLint configuration:
-
 - `core()` - Essential rules for all JavaScript/TypeScript projects
-- `node()` - Node.js specific rules
-- `react()` - React framework rules
 - `typescript()` - TypeScript parser and rules
 - `typescriptStrict()` - Additional strict TypeScript rules
+- `react()` - React framework rules
+- `next()` - Next.js framework
+- `node()` - Node.js specific rules
 - `jest()` - Jest testing framework
 - `vitest()` - Vitest testing framework
 - `playwright()` - Playwright e2e testing
 - `mobx()` - MobX state management
-- `next()` - Next.js framework
 - `storybook()` - Storybook
+- `packageJson()` - package.json linting
+- `packageJsonWorkspace()` - package.json linting for monorepos
 
 ### Customizing Configs
 
-Each factory function accepts a `config` parameter to extend or override settings:
+Each factory function accepts a config parameter to extend or override settings:
 
 ```js
 import { customDefineConfig, core, typescript } from "@dvukovic/style-guide/eslint"
 
 export default customDefineConfig(
-    [],
+    ["dist"],
     [
         core(),
         typescript({
@@ -56,105 +67,87 @@ export default customDefineConfig(
 )
 ```
 
-### Scripts
+## Prettier
 
-Add these scripts to your `package.json`:
+Create `prettier.config.ts`:
 
-```json
-{
-    "scripts": {
-        "lint": "yarn lint:eslint && yarn lint:prettier && yarn lint:stylelint && yarn lint:spell",
-        "lint:eslint": "eslint . --cache --concurrency=auto",
-        "lint:fix": "yarn lint:eslint --fix && yarn lint:prettier --write && yarn lint:stylelint --fix && yarn lint:spell",
-        "lint:prettier": "prettier --check --cache .",
-        "lint:spell": "cspell --no-progress --no-summary --unique '**'",
-        "lint:stylelint": "stylelint ./**/*.css --cache",
-        "test": "vitest run"
-    }
+```ts
+import type { Config } from "prettier"
+
+import { core } from "@dvukovic/style-guide/prettier"
+
+const config: Config = {
+    ...core,
 }
+
+export default config
 ```
 
-### Complete Example
+## Stylelint
 
-A full-featured project (this is the actual config used by this package):
+Create `stylelint.config.js`:
 
 ```js
-import {
-    customDefineConfig,
-    core,
-    node,
-    mobx,
-    react,
-    next,
-    typescript,
-    typescriptStrict,
-    jest,
-    vitest,
-    playwright,
-} from "@dvukovic/style-guide/eslint"
+import stylelintConfig from "@dvukovic/style-guide/stylelint"
 
-export default customDefineConfig(
-    ["node_modules"],
-    [
-        core(),
-        node(),
-        mobx(),
-        react(),
-        next(),
-        typescript(),
-        typescriptStrict(),
-        jest(),
-        vitest(),
-        playwright(),
-    ],
-)
+/** @type {import("stylelint").Config} */
+const config = {
+    ...stylelintConfig,
+}
+
+export default config
 ```
 
-## Prettier Configuration
+## CSpell
 
-```js prettier.config.ts
-import type { Config } from "prettier"
+Create `cspell.config.js`:
 
-import core from "@dvukovic/style-guide/src/prettier/configs/core.js"
+```js
+import cspellConfig from "@dvukovic/style-guide/cspell"
 
-const config: Config = {
-    ...core,
+/** @type {import("cspell").FileSettings} */
+const config = {
+    ...cspellConfig,
+    ignorePaths: [],
+    ignoreWords: [],
 }
 
 export default config
 ```
 
-## Stylelint Configuration
+## Knip
 
-```js stylelint.config.js
-/** @type {import("stylelint").Config} */
-module.exports = {
-    extends: "@dvukovic/style-guide/src/stylelint/configs/core",
-    allowEmptyInput: true,
+Create `knip.config.ts`:
+
+```ts
+import type { KnipConfig } from "knip"
+
+import { core } from "@dvukovic/style-guide/knip"
+
+const config: KnipConfig = {
+    ...core,
+    ignore: [],
+    ignoreDependencies: [...core.ignoreDependencies],
 }
+
+export default config
 ```
 
-## Cspell Configuration
+## Scripts
 
-```cspell.config.js
-/** @type {import("cspell").FileSettings} */
-module.exports = {
-    cache: {
-        cacheLocation: "./node_modules/.cache/cspell",
-        useCache: true,
-    },
-    caseSensitive: false,
-    ignorePaths: [],
-    dictionaries: ["shared"],
-    dictionaryDefinitions: [
-        {
-            name: "shared",
-            path: "./node_modules/@dvukovic/style-guide/src/cspell/base.txt",
-        },
-    ],
-    useGitignore: true,
-    ignoreWords: [
-    ],
+Add to your `package.json`:
+
+```json
+{
+    "scripts": {
+        "lint": "yarn lint:eslint && yarn lint:prettier && yarn lint:stylelint && yarn lint:cspell && yarn lint:knip",
+        "lint:eslint": "eslint . --cache --concurrency=auto",
+        "lint:prettier": "prettier --check --cache .",
+        "lint:stylelint": "stylelint ./**/*.css --cache",
+        "lint:cspell": "cspell --no-progress --no-summary --unique '**'",
+        "lint:knip": "knip",
+        "lint:fix": "yarn lint:eslint --fix && yarn lint:prettier --write && yarn lint:stylelint --fix"
+    }
 }
 ```
 

package/dist/cli/generators/cspell.d.ts

@@ -0,0 +1 @@
+export function generateCspellConfig(): string;

package/dist/cli/generators/eslint.d.ts

@@ -0,0 +1 @@
+export function generateESLintConfig(options: any): string;

package/dist/cli/generators/knip.d.ts

@@ -0,0 +1 @@
+export function generateKnipConfig(): string;

package/dist/cli/generators/prettier.d.ts

@@ -0,0 +1 @@
+export function generatePrettierConfig(): string;

package/dist/cli/generators/scripts.d.ts

@@ -0,0 +1,9 @@
+export function generateScripts(tools: any, packageManager: any): {
+    "lint:eslint": string;
+    "lint:prettier": string;
+    "lint:stylelint": string;
+    "lint:cspell": string;
+    "lint:knip": string;
+    lint: string;
+    "lint:fix": string;
+};

package/dist/cli/generators/stylelint.d.ts

@@ -0,0 +1 @@
+export function generateStylelintConfig(): string;

package/dist/cli/index.d.ts

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

package/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export function runInit(): Promise<void>;

package/dist/cli/prompts.d.ts

@@ -0,0 +1,13 @@
+export function promptToolSelection(): Promise<string[]>;
+export function promptESLintOptions(): Promise<{
+    extras: ("mobx" | "storybook")[];
+    framework: "none" | "react" | "next";
+    includeNode: boolean;
+    isMonorepo: boolean;
+    language: "typescript" | "javascript";
+    strictMode: boolean;
+    testing: ("jest" | "vitest" | "playwright")[];
+}>;
+export function promptOverwrite(filename: any): Promise<boolean>;
+export function promptInstall(packageManager: any, packages: any): Promise<boolean>;
+export function promptAddScripts(): Promise<boolean>;

package/dist/cspell/configs/core.d.ts

@@ -0,0 +1,3 @@
+export default config;
+/** @type {import("cspell").FileSettings} */
+declare const config: import("cspell").FileSettings;

package/dist/cspell/index.d.ts

@@ -0,0 +1 @@
+export { default as core, default } from "./configs/core.js";

package/dist/eslint/rules/no-commented-out-code/no-commented-out-code.utils.d.ts

@@ -1,4 +1,3 @@
-export function isExpressionOrIdentifierOrLiteral(node: any): any;
 export function hasEmptyBody(program: any): boolean;
 export function hasExpressionBody(program: any): any;
 export function hasLabeledStatementBody(program: any): boolean;

package/dist/knip/configs/core.d.ts

@@ -0,0 +1,3 @@
+export default config;
+/** @type {import("knip").KnipConfig} */
+declare const config: import("knip").KnipConfig;

package/dist/knip/index.d.ts

@@ -0,0 +1 @@
+export { default as core } from "./configs/core.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.5.2",
+    "version": "0.7.0",
     "description": "My own style guide",
     "repository": {
         "type": "git",
@@ -12,11 +12,19 @@
     },
     "type": "module",
     "exports": {
-        "./cspell/dictionary.txt": "./src/cspell/dictionary.txt",
+        "./cspell": {
+            "types": "./dist/cspell/index.d.ts",
+            "default": "./src/cspell/index.js"
+        },
+        "./cspell/base.txt": "./src/cspell/base.txt",
         "./eslint": {
             "types": "./dist/eslint/index.d.ts",
             "default": "./src/eslint/index.js"
         },
+        "./knip": {
+            "types": "./dist/knip/index.d.ts",
+            "default": "./src/knip/index.js"
+        },
         "./prettier": {
             "types": "./dist/prettier/index.d.ts",
             "default": "./src/prettier/index.js"
@@ -26,31 +34,34 @@
             "default": "./src/stylelint/index.js"
         }
     },
+    "bin": "./src/cli/index.js",
     "files": [
         "dist",
+        "src/cli",
         "src/cspell",
         "src/eslint",
+        "src/knip",
         "src/package-json",
         "src/prettier",
         "src/stylelint"
     ],
     "scripts": {
         "build": "tsc",
-        "lint": "yarn lint:eslint && yarn lint:prettier && yarn lint:stylelint && yarn lint:cspell",
+        "lint": "yarn lint:eslint && yarn lint:prettier && yarn lint:stylelint && yarn lint:cspell && yarn lint:knip",
         "lint:cspell": "cspell --no-progress --no-summary --unique '**'",
         "lint:eslint": "eslint . --cache --concurrency=auto",
-        "lint:fix": "yarn lint:eslint --fix && yarn lint:prettier --write && yarn lint:stylelint --fix && yarn lint:cspell",
+        "lint:fix": "yarn lint:eslint --fix && yarn lint:prettier --write && yarn lint:stylelint --fix && yarn lint:cspell && yarn lint:knip",
+        "lint:knip": "knip",
         "lint:prettier": "prettier --check --cache .",
         "lint:stylelint": "stylelint ./**/*.css --cache",
         "release": "release-it",
         "test": "vitest run"
     },
     "dependencies": {
+        "@clack/prompts": "0.10.0",
         "@eslint-community/eslint-plugin-eslint-comments": "4.5.0",
-        "@eslint/compat": "2.0.0",
         "@eslint/config-helpers": "0.4.2",
         "@next/eslint-plugin-next": "16.1.0",
-        "@prettier/plugin-xml": "3.4.2",
         "@rimac-technology/eslint-plugin": "1.5.0",
         "@stylistic/eslint-plugin": "5.6.1",
         "@typescript-eslint/parser": "8.50.0",
@@ -90,10 +101,10 @@
     },
     "devDependencies": {
         "@release-it/conventional-changelog": "10.0.4",
-        "@types/eslint": "9.6.1",
         "@types/node": "24.10.4",
         "cspell": "9.4.0",
         "eslint": "9.39.2",
+        "knip": "5.82.1",
         "prettier": "3.7.4",
         "release-it": "19.1.0",
         "stylelint": "16.26.1",
@@ -103,6 +114,7 @@
     "peerDependencies": {
         "cspell": "9",
         "eslint": "^9",
+        "knip": "5",
         "prettier": "3",
         "stylelint": "16"
     },
@@ -113,6 +125,9 @@
         "eslint": {
             "optional": true
         },
+        "knip": {
+            "optional": true
+        },
         "prettier": {
             "optional": true
         },

package/src/cli/generators/cspell.js

@@ -0,0 +1,13 @@
+export function generateCspellConfig() {
+    return `import cspellConfig from "@dvukovic/style-guide/cspell"
+
+/** @type {import("cspell").FileSettings} */
+const config = {
+    ...cspellConfig,
+    ignorePaths: [],
+    ignoreWords: [],
+}
+
+export default config
+`
+}

package/src/cli/generators/eslint.js

@@ -0,0 +1,80 @@
+export function generateESLintConfig(options) {
+    const { extras, framework, includeNode, isMonorepo, language, strictMode, testing } = options
+
+    const imports = ["core", "customDefineConfig"]
+    const configs = ["core()"]
+    const ignores = ["dist", "node_modules"]
+
+    if (language === "typescript") {
+        imports.push("typescript")
+        configs.push("typescript()")
+
+        if (strictMode) {
+            imports.push("typescriptStrict")
+            configs.push("typescriptStrict()")
+        }
+    }
+
+    if (framework === "react") {
+        imports.push("react")
+        configs.push("react()")
+        ignores.push("build")
+    }
+
+    if (framework === "next") {
+        imports.push("next")
+        configs.push("next()")
+        ignores.push(".next", "out")
+    }
+
+    if (includeNode) {
+        imports.push("node")
+        configs.push("node()")
+    }
+
+    if (testing.includes("jest")) {
+        imports.push("jest")
+        configs.push("jest()")
+    }
+
+    if (testing.includes("vitest")) {
+        imports.push("vitest")
+        configs.push("vitest()")
+    }
+
+    if (testing.includes("playwright")) {
+        imports.push("playwright")
+        configs.push("playwright()")
+    }
+
+    if (extras.includes("mobx")) {
+        imports.push("mobx")
+        configs.push("mobx()")
+    }
+
+    if (extras.includes("storybook")) {
+        imports.push("storybook")
+        configs.push("storybook()")
+    }
+
+    if (isMonorepo) {
+        imports.push("packageJsonWorkspace")
+        configs.push("...packageJsonWorkspace()")
+    } else {
+        imports.push("packageJson")
+        configs.push("packageJson()")
+    }
+
+    const importStatement = `import {\n    ${imports.join(",\n    ")},\n} from "@dvukovic/style-guide/eslint"`
+
+    const ignoresArray = `["${ignores.join('", "')}"]`
+    const configsArray = `[\n        ${configs.join(",\n        ")},\n    ]`
+
+    return `${importStatement}
+
+export default customDefineConfig(
+    ${ignoresArray},
+    ${configsArray},
+)
+`
+}

package/src/cli/generators/knip.js

@@ -0,0 +1,14 @@
+export function generateKnipConfig() {
+    return `import type { KnipConfig } from "knip"
+
+import { core } from "@dvukovic/style-guide/knip"
+
+const config: KnipConfig = {
+    ...core,
+    ignore: [],
+    ignoreDependencies: [...core.ignoreDependencies],
+}
+
+export default config
+`
+}

package/src/cli/generators/prettier.js

@@ -0,0 +1,12 @@
+export function generatePrettierConfig() {
+    return `import type { Config } from "prettier"
+
+import { core } from "@dvukovic/style-guide/prettier"
+
+const config: Config = {
+    ...core,
+}
+
+export default config
+`
+}

package/src/cli/generators/scripts.js

@@ -0,0 +1,45 @@
+export function generateScripts(tools, packageManager) {
+    const runner = packageManager === "npm" ? "npm run" : packageManager
+
+    const scripts = {}
+    const lintParts = []
+    const fixParts = []
+
+    if (tools.includes("eslint")) {
+        scripts["lint:eslint"] = "eslint . --cache --concurrency=auto"
+        lintParts.push(`${runner} lint:eslint`)
+        fixParts.push(`${runner} lint:eslint --fix`)
+    }
+
+    if (tools.includes("prettier")) {
+        scripts["lint:prettier"] = "prettier --check --cache ."
+        lintParts.push(`${runner} lint:prettier`)
+        fixParts.push(`${runner} lint:prettier --write`)
+    }
+
+    if (tools.includes("stylelint")) {
+        scripts["lint:stylelint"] = "stylelint ./**/*.css --cache"
+        lintParts.push(`${runner} lint:stylelint`)
+        fixParts.push(`${runner} lint:stylelint --fix`)
+    }
+
+    if (tools.includes("cspell")) {
+        scripts["lint:cspell"] = "cspell --no-progress --no-summary --unique '**'"
+        lintParts.push(`${runner} lint:cspell`)
+    }
+
+    if (tools.includes("knip")) {
+        scripts["lint:knip"] = "knip"
+        lintParts.push(`${runner} lint:knip`)
+    }
+
+    if (lintParts.length > 0) {
+        scripts.lint = lintParts.join(" && ")
+    }
+
+    if (fixParts.length > 0) {
+        scripts["lint:fix"] = fixParts.join(" && ")
+    }
+
+    return scripts
+}

package/src/cli/generators/stylelint.js

@@ -0,0 +1,11 @@
+export function generateStylelintConfig() {
+    return `import stylelintConfig from "@dvukovic/style-guide/stylelint"
+
+/** @type {import("stylelint").Config} */
+const config = {
+    ...stylelintConfig,
+}
+
+export default config
+`
+}

package/src/cli/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { intro, outro } from "@clack/prompts"
+
+import { runInit } from "./init.js"
+
+const command = process.argv[2]
+
+if (command === "init") {
+    intro("@dvukovic/style-guide")
+    await runInit()
+    outro("Configuration complete!")
+} else {
+    process.stderr.write("Usage: style-guide init\n")
+    process.stderr.write("\n")
+    process.stderr.write("Commands:\n")
+    process.stderr.write("  init    Initialize configuration files\n")
+    // eslint-disable-next-line n/no-process-exit -- CLI entry point
+    process.exit(1)
+}

package/src/cli/init.js

@@ -0,0 +1,221 @@
+import { execSync } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { writeFile } from "node:fs/promises"
+
+import * as clack from "@clack/prompts"
+
+import { generateCspellConfig } from "./generators/cspell.js"
+import { generateESLintConfig } from "./generators/eslint.js"
+import { generateKnipConfig } from "./generators/knip.js"
+import { generatePrettierConfig } from "./generators/prettier.js"
+import { generateScripts } from "./generators/scripts.js"
+import { generateStylelintConfig } from "./generators/stylelint.js"
+import {
+    promptAddScripts,
+    promptESLintOptions,
+    promptInstall,
+    promptOverwrite,
+    promptToolSelection,
+} from "./prompts.js"
+
+const TOOL_PACKAGES = {
+    cspell: "cspell",
+    eslint: "eslint",
+    knip: "knip",
+    prettier: "prettier",
+    stylelint: "stylelint",
+}
+
+function detectPackageManager() {
+    if (existsSync("pnpm-lock.yaml")) {
+        return "pnpm"
+    }
+
+    if (existsSync("yarn.lock")) {
+        return "yarn"
+    }
+
+    if (existsSync("bun.lockb")) {
+        return "bun"
+    }
+
+    return "npm"
+}
+
+function getInstalledPackages() {
+    try {
+        const packageJson = JSON.parse(readFileSync("package.json", "utf8"))
+
+        return {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        }
+    } catch {
+        return {}
+    }
+}
+
+function getMissingPackages(tools) {
+    const installed = getInstalledPackages()
+    const missing = []
+
+    if (!("@dvukovic/style-guide" in installed)) {
+        missing.push("@dvukovic/style-guide")
+    }
+
+    for (const tool of tools) {
+        const packageName = TOOL_PACKAGES[tool]
+
+        if (packageName && !(packageName in installed)) {
+            missing.push(packageName)
+        }
+    }
+
+    return missing
+}
+
+async function installPackages(tools, packageManager) {
+    const missingPackages = getMissingPackages(tools)
+
+    if (missingPackages.length === 0) {
+        return
+    }
+
+    const shouldInstall = await promptInstall(packageManager, missingPackages)
+
+    if (!shouldInstall) {
+        return
+    }
+
+    const packages = missingPackages.join(" ")
+    const installCmd =
+        packageManager === "npm"
+            ? `npm install -D ${packages}`
+            : `${packageManager} add -D ${packages}`
+
+    const spinner = clack.spinner()
+
+    spinner.start("Installing packages")
+
+    try {
+        // eslint-disable-next-line sonarjs/os-command -- User-confirmed install command
+        execSync(installCmd, { stdio: "pipe" })
+        spinner.stop("Packages installed")
+    } catch {
+        spinner.stop("Failed to install. Please run manually:")
+        clack.log.info(`  ${installCmd}`)
+    }
+}
+
+async function writeConfigFile(filename, content) {
+    if (existsSync(filename)) {
+        const overwrite = await promptOverwrite(filename)
+
+        if (!overwrite) {
+            clack.log.info(`Skipped ${filename}`)
+
+            return false
+        }
+    }
+
+    await writeFile(filename, content)
+    clack.log.success(`Created ${filename}`)
+
+    return true
+}
+
+async function updatePackageJsonScripts(tools, packageManager) {
+    const scripts = generateScripts(tools, packageManager)
+
+    if (Object.keys(scripts).length === 0) {
+        return
+    }
+
+    try {
+        const packageJsonContent = readFileSync("package.json", "utf8")
+        const packageJson = JSON.parse(packageJsonContent)
+
+        packageJson.scripts = {
+            ...packageJson.scripts,
+            ...scripts,
+        }
+
+        const sortedKeys = Object.keys(packageJson.scripts).sort((left, right) => {
+            return left.localeCompare(right)
+        })
+        const sortedScripts = {}
+
+        for (const key of sortedKeys) {
+            sortedScripts[key] = packageJson.scripts[key]
+        }
+
+        packageJson.scripts = sortedScripts
+
+        await writeFile("package.json", `${JSON.stringify(packageJson, null, 4)}\n`)
+        clack.log.success("Added scripts to package.json")
+    } catch {
+        clack.log.error("Failed to update package.json scripts")
+    }
+}
+
+export async function runInit() {
+    const tools = await promptToolSelection()
+
+    let eslintOptions = null
+
+    if (tools.includes("eslint")) {
+        eslintOptions = await promptESLintOptions()
+    }
+
+    const shouldAddScripts = await promptAddScripts()
+    const packageManager = detectPackageManager()
+
+    await installPackages(tools, packageManager)
+
+    const spinner = clack.spinner()
+
+    spinner.start("Generating configuration files")
+
+    const results = []
+
+    if (tools.includes("eslint") && eslintOptions) {
+        const content = generateESLintConfig(eslintOptions)
+
+        results.push({ content, filename: "eslint.config.js" })
+    }
+
+    if (tools.includes("prettier")) {
+        const content = generatePrettierConfig()
+
+        results.push({ content, filename: "prettier.config.ts" })
+    }
+
+    if (tools.includes("stylelint")) {
+        const content = generateStylelintConfig()
+
+        results.push({ content, filename: "stylelint.config.js" })
+    }
+
+    if (tools.includes("cspell")) {
+        const content = generateCspellConfig()
+
+        results.push({ content, filename: "cspell.config.js" })
+    }
+
+    if (tools.includes("knip")) {
+        const content = generateKnipConfig()
+
+        results.push({ content, filename: "knip.config.ts" })
+    }
+
+    spinner.stop("Configuration files generated")
+
+    for (const { content, filename } of results) {
+        // eslint-disable-next-line no-await-in-loop -- Sequential writes for user feedback
+        await writeConfigFile(filename, content)
+    }
+
+    if (shouldAddScripts) {
+        await updatePackageJsonScripts(tools, packageManager)
+    }
+}

package/src/cli/prompts.js

@@ -0,0 +1,196 @@
+import * as clack from "@clack/prompts"
+
+class SetupCancelledError extends Error {
+    constructor() {
+        super("Setup cancelled.")
+        this.name = "SetupCancelledError"
+    }
+}
+
+export async function promptToolSelection() {
+    const tools = await clack.multiselect({
+        initialValues: ["eslint", "prettier"],
+        message: "Which tools would you like to configure?",
+        options: [
+            { label: "ESLint", value: "eslint" },
+            { label: "Prettier", value: "prettier" },
+            { label: "Stylelint", value: "stylelint" },
+            { label: "CSpell", value: "cspell" },
+            { label: "Knip", value: "knip" },
+        ],
+        required: true,
+    })
+
+    if (clack.isCancel(tools)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    return tools
+}
+
+export async function promptESLintOptions() {
+    const language = await clack.select({
+        message: "Which language are you using?",
+        options: [
+            { label: "TypeScript", value: "typescript" },
+            { label: "JavaScript only", value: "javascript" },
+        ],
+    })
+
+    if (clack.isCancel(language)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    let strictMode = false
+
+    if (language === "typescript") {
+        const strict = await clack.select({
+            message: "TypeScript strictness level?",
+            options: [
+                { label: "Standard", value: "standard" },
+                { label: "Strict (additional type-checked rules)", value: "strict" },
+            ],
+        })
+
+        if (clack.isCancel(strict)) {
+            clack.cancel("Setup cancelled.")
+
+            throw new SetupCancelledError()
+        }
+
+        strictMode = strict === "strict"
+    }
+
+    const framework = await clack.select({
+        message: "Which framework are you using?",
+        options: [
+            { label: "None (Node.js)", value: "none" },
+            { label: "React", value: "react" },
+            { label: "Next.js", value: "next" },
+        ],
+    })
+
+    if (clack.isCancel(framework)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    let includeNode = framework === "none"
+
+    if (framework !== "none") {
+        const nodeBackend = await clack.confirm({
+            initialValue: false,
+            message: "Do you have a Node.js backend?",
+        })
+
+        if (clack.isCancel(nodeBackend)) {
+            clack.cancel("Setup cancelled.")
+
+            throw new SetupCancelledError()
+        }
+
+        includeNode = nodeBackend
+    }
+
+    const testing = await clack.multiselect({
+        message: "Which testing frameworks do you use?",
+        options: [
+            { label: "Jest", value: "jest" },
+            { label: "Vitest", value: "vitest" },
+            { label: "Playwright", value: "playwright" },
+        ],
+        required: false,
+    })
+
+    if (clack.isCancel(testing)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    const extras = await clack.multiselect({
+        message: "Any additional configurations?",
+        options: [
+            { label: "MobX", value: "mobx" },
+            { label: "Storybook", value: "storybook" },
+        ],
+        required: false,
+    })
+
+    if (clack.isCancel(extras)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    const monorepo = await clack.confirm({
+        initialValue: false,
+        message: "Is this a monorepo?",
+    })
+
+    if (clack.isCancel(monorepo)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    const isMonorepo = monorepo
+
+    return {
+        extras,
+        framework,
+        includeNode,
+        isMonorepo,
+        language,
+        strictMode,
+        testing,
+    }
+}
+
+export async function promptOverwrite(filename) {
+    const overwrite = await clack.confirm({
+        initialValue: false,
+        message: `${filename} already exists. Overwrite?`,
+    })
+
+    if (clack.isCancel(overwrite)) {
+        clack.cancel("Setup cancelled.")
+
+        throw new SetupCancelledError()
+    }
+
+    return overwrite
+}
+
+export async function promptInstall(packageManager, packages) {
+    const packageList = packages.join(", ")
+
+    const install = await clack.confirm({
+        initialValue: true,
+        message: `Install ${packageList} using ${packageManager}?`,
+    })
+
+    if (clack.isCancel(install)) {
+        return false
+    }
+
+    return install
+}
+
+export async function promptAddScripts() {
+    const addScripts = await clack.confirm({
+        initialValue: true,
+        message: "Add lint scripts to package.json?",
+    })
+
+    if (clack.isCancel(addScripts)) {
+        return false
+    }
+
+    return addScripts
+}

package/src/cspell/configs/core.js

@@ -0,0 +1,18 @@
+/** @type {import("cspell").FileSettings} */
+const config = {
+    cache: {
+        cacheLocation: "./node_modules/.cache/cspell",
+        useCache: true,
+    },
+    caseSensitive: false,
+    dictionaries: ["shared"],
+    dictionaryDefinitions: [
+        {
+            name: "shared",
+            path: "./node_modules/@dvukovic/style-guide/cspell/base.txt",
+        },
+    ],
+    useGitignore: true,
+}
+
+export default config

package/src/cspell/index.js

@@ -0,0 +1 @@
+export { default as core, default } from "./configs/core.js"

package/src/eslint/rules/no-commented-out-code/no-commented-out-code.utils.js

@@ -1,4 +1,4 @@
-export function isExpressionOrIdentifierOrLiteral(node) {
+function isExpressionOrIdentifierOrLiteral(node) {
     if (node.type === "Identifier") {
         return true
     }

package/src/knip/configs/core.js

@@ -0,0 +1,14 @@
+/** @type {import("knip").KnipConfig} */
+const config = {
+    ignore: [],
+    ignoreDependencies: [
+        "cspell",
+        "eslint",
+        "prettier",
+        "stylelint",
+        "stylelint-no-unused-selectors",
+        "stylelint-order",
+    ],
+}
+
+export default config

package/src/knip/index.d.ts

@@ -0,0 +1,3 @@
+import type { KnipConfig } from "knip"
+
+export declare const core: KnipConfig

package/src/knip/index.js

@@ -0,0 +1 @@
+export { default as core } from "./configs/core.js"