@nustackjs/lint 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 - Present Zerya and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# NuStack Lint
+
+[![Nuxt][nuxt-src]][nuxt-href]
+
+> [!CAUTION]
+> Very early in development. The ESLint engine is a stepping stone toward an
+> oxlint-based v1.0 — see the [roadmap](./docs/roadmap.md). Don't depend on it yet.
+
+Zero-config ESLint for Nuxt. Add one module and get a full setup — no `eslint.config` to
+assemble, no plugin list to keep in sync across projects. It detects what your project
+uses and turns on the rules that fit, on top of
+[`@nuxt/eslint`](https://eslint.nuxt.com) and
+[`@antfu/eslint-config`](https://github.com/antfu/eslint-config). Part of
+[NuStack](../../README.md).
+
+Three reasons it exists:
+
+- **Plug it in.** Stop reconfiguring lint on every project. One module bundles and wires
+  the antfu base, `@nuxt/eslint`, and a growing set of Nuxt-aware rules, and upgrades
+  them together.
+- **Catch more.** Deep, Nuxt-aware checks that go well past formatting — promoting
+  ecosystem best practices and catching the slop that otherwise slips through code
+  review, including what AI agents generate. The ruleset keeps growing. The custom rules
+  ship as standalone, [Oxlint](https://oxc.rs)-ready plugins
+  ([nuxt](../../packages/lint-plugin-nuxt), [vueuse](../../packages/lint-plugin-vueuse),
+  [vite](../../packages/lint-plugin-vite),
+  [nuxt-ecosystem](../../packages/lint-plugin-nuxt-ecosystem)) that you can also use on
+  their own.
+- **Policy as code.** When there are several ways to do the same thing, it picks one and
+  enforces it — so the decision lives in the linter instead of in every code review.
+  Disagree with a pick? Override it; everything is configurable.
+
+## Setup
+
+```bash
+npx nuxi module add @nustackjs/lint
+```
+
+That's the only module you list — `@nuxt/eslint` is bundled and installed for you (in
+composable mode), so there's no `eslint` key to configure:
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@nustackjs/lint'],
+})
+```
+
+Then point `eslint.config.ts` at the generated config (it already wires in `withNuxt()`
+for you — config lives here, not in `nuxt.config`):
+
+```ts
+// eslint.config.ts
+export { default } from './.nuxt/nustack-eslint.mjs'
+```
+
+To pass options, call the factory instead — same file, `withNuxt()` still prewired:
+
+```ts
+// eslint.config.ts
+import { nustack } from './.nuxt/nustack-eslint.mjs'
+
+export default nustack({ variant: 'pedantic' })
+```
+
+```bash
+eslint .                            # quick checks (fast)
+NUSTACK_LINT_DEPTH=full eslint .    # + type-aware checks (CI)
+```
+
+See [Configuration](./docs/configuration.md), [Rules](./docs/rules.md) and
+[Migration](./docs/migration.md).
+
+## Non-Nuxt projects
+
+```ts
+// eslint.config.ts
+import nustack from '@nustackjs/lint/config'
+
+export default nustack({ base: { type: 'lib' } })
+```
+
+## Config inspector
+
+```bash
+npx @eslint/config-inspector --config eslint.config.ts
+```
+
+## Contributing
+
+`DEVELOPMENT.md` is the design contract — read it first.
+
+```bash
+pnpm install
+pnpm dev:prepare   # build module + nuxt prepare playground
+pnpm lint          # dogfoods the preset on its own source
+pnpm test
+```
+
+## License
+
+[MIT](./LICENSE) © Zerya
+
+<!-- Badges -->
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import { Linter } from 'eslint';
+import { FlatConfigComposer } from 'eslint-flat-config-utils';
+import antfu from '@antfu/eslint-config';
+import { N as NustackContext } from './shared/lint.Cq_cclOu.mjs';
+export { E as EMPTY_CONTEXT } from './shared/lint.Cq_cclOu.mjs';
+
+type Rules = Record<string, Linter.RuleEntry>;
+/** Opinion strength — static, set in `eslint.config.ts`. Cumulative. */
+type Variant = 'minimal' | 'recommended' | 'pedantic';
+/** Analysis depth — per-run, from `NUSTACK_LINT_DEPTH`. Cumulative. */
+type Depth = 'quick' | 'full';
+/** Base options shared by every per-concern option object. */
+interface ConcernOptions {
+    /** Per-concern rule changes, merged after the concern's defaults. */
+    rules?: Rules;
+    /** @deprecated Use `rules` instead. */
+    overrides?: Rules;
+}
+
+/** Options accepted by `@antfu/eslint-config`'s factory. */
+type AntfuOptions = NonNullable<Parameters<typeof antfu>[0]>;
+
+interface NuxtConcernOptions extends ConcernOptions {
+}
+
+interface NuxtUiConcernOptions extends ConcernOptions {
+}
+
+interface TailwindConcernOptions extends ConcernOptions {
+    /** Override the auto-detected Tailwind entry point (`@import "tailwindcss"`). */
+    entryPoint?: string;
+    /**
+     * Extra `better-tailwindcss` shared settings, merged over the defaults — e.g.
+     * `attributes`, `callees`, `tailwindConfig`. Rule options (printWidth etc.) go
+     * through `rules`, not here.
+     */
+    settings?: Record<string, unknown>;
+}
+
+interface ViteConcernOptions extends ConcernOptions {
+}
+
+interface VueConcernOptions extends ConcernOptions {
+}
+
+interface VueUseConcernOptions extends ConcernOptions {
+}
+
+type Awaitable<T> = T | Promise<T>;
+type NustackFlatConfig = Linter.Config | Linter.Config[] | FlatConfigComposer;
+type NustackUserConfig = Awaitable<NustackFlatConfig>;
+/** A per-concern toggle: `true`/`undefined` = default, `false` = off, object = tune. */
+type ConcernToggle<T> = boolean | T;
+/**
+ * Options for the public nustack ESLint factory. Mirrors `@antfu/eslint-config`'s
+ * shape: one options object, then optional flat config objects appended last.
+ * `depth` is intentionally absent — it is read per-run from `NUSTACK_LINT_DEPTH`.
+ */
+interface NustackLintOptions {
+    /** Opinion strength. Default `recommended`. Cumulative: minimal ⊂ recommended ⊂ pedantic. */
+    variant?: Variant;
+    /** The antfu style base. Object tunes it, `false` disables it. */
+    base?: AntfuOptions | false;
+    /** Core Nuxt conventions (auto-imports, runtimeConfig, process.env). */
+    nuxt?: ConcernToggle<NuxtConcernOptions>;
+    /** SFC conventions (vue/block-lang etc.). */
+    vue?: ConcernToggle<VueConcernOptions>;
+    /** VueUse usage conventions. */
+    vueUse?: ConcernToggle<VueUseConcernOptions>;
+    /** Vite build/runtime conventions. */
+    vite?: ConcernToggle<ViteConcernOptions>;
+    /** Nuxt UI component preferences. Auto-gated on `@nuxt/ui` detection. */
+    nuxtUi?: ConcernToggle<NuxtUiConcernOptions>;
+    /** Tailwind class sorting/correctness. Auto-gated on a detected entry point. */
+    tailwind?: ConcernToggle<TailwindConcernOptions>;
+    /** Global rule changes, merged after every concern. */
+    rules?: Rules;
+    /** @deprecated Use `rules` instead. */
+    overrides?: Rules;
+    /** Detected project context. Injected by the generated `.nuxt/nustack-eslint.mjs`. */
+    context?: NustackContext;
+}
+type NustackOptions = NustackLintOptions;
+/**
+ * Wraps a `withNuxt()` composer with the full nustack config. Mirrors antfu: the
+ * style base is prepended, then each enabled, context-gated concern is appended,
+ * then global rules and user flat configs. Returns the same composer for chaining.
+ *
+ * The generated `.nuxt/nustack-eslint.mjs` calls this with the detected context in
+ * `options.context`; callers normally import the pre-bound `nustack` from there
+ * and may pass their own options plus file-scoped flat configs.
+ */
+declare function applyNustackConfig(base: FlatConfigComposer, options?: NustackLintOptions, ...userConfigs: NustackUserConfig[]): FlatConfigComposer;
+/**
+ * Public standalone (non-Nuxt) entry. Builds a composer from scratch — no `withNuxt()` —
+ * so a plain TypeScript/Vue repo can consume the nustack preset directly. The
+ * Nuxt/project-detected concerns default off here since there's no Nuxt project
+ * to detect; enable them explicitly if you want them. Used to dogfood `@nustackjs/lint`
+ * on its own (non-Nuxt) source.
+ */
+declare function nustack(options?: NustackLintOptions, ...userConfigs: NustackUserConfig[]): FlatConfigComposer;
+
+export { NustackContext, applyNustackConfig, nustack as default, nustack };
+export type { Awaitable, Depth, NustackFlatConfig, NustackLintOptions, NustackOptions, NustackUserConfig, Rules, Variant };

package/dist/index.mjs

@@ -0,0 +1,346 @@
+import { defu } from 'defu';
+import { composer } from 'eslint-flat-config-utils';
+import antfu from '@antfu/eslint-config';
+import nuxtPlugin from '@nustackjs/lint-plugin-nuxt';
+import nuxtEcosystemPlugin from '@nustackjs/lint-plugin-nuxt-ecosystem';
+import betterTailwind from 'eslint-plugin-better-tailwindcss';
+import { getDefaultCallees, getDefaultAttributes } from 'eslint-plugin-better-tailwindcss/api/defaults';
+import { MatcherType } from 'eslint-plugin-better-tailwindcss/api/types';
+import vitePlugin from '@nustackjs/lint-plugin-vite';
+import vueUsePlugin from '@nustackjs/lint-plugin-vueuse';
+
+const ANTFU_DEFAULTS = {
+  stylistic: true,
+  vue: true,
+  rules: {
+    // Nuxt pages/layouts legitimately have multiple root nodes.
+    "vue/no-multiple-template-root": "off",
+    // `process` is a Nuxt/Nitro global; @nustack/nuxt/no-process-env handles app code.
+    "node/prefer-global/process": "off",
+    "style/brace-style": ["warn", "1tbs"]
+  }
+};
+function resolveTypescriptOptions(userBase, depth) {
+  const userTypescript = userBase?.typescript;
+  if (depth === "full") {
+    return defu(
+      typeof userTypescript === "object" && userTypescript !== null ? userTypescript : {},
+      { tsconfigPath: "tsconfig.json" }
+    );
+  }
+  return typeof userTypescript === "object" && userTypescript !== null ? userTypescript : true;
+}
+function antfuBase(userBase, depth) {
+  if (userBase === false)
+    return null;
+  return antfu({
+    ...defu(userBase, ANTFU_DEFAULTS),
+    typescript: resolveTypescriptOptions(userBase, depth)
+  });
+}
+
+const VARIANT_ORDER = { minimal: 0, recommended: 1, pedantic: 2 };
+function variantAtLeast(variant, min) {
+  return VARIANT_ORDER[variant] >= VARIANT_ORDER[min];
+}
+function resolveConcernRules(options) {
+  return {
+    ...options.overrides,
+    ...options.rules
+  };
+}
+
+const GLOB_APP$2 = ["**/*.vue", "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"];
+const GLOB_NUXT_CONFIG = ["**/nuxt.config.{ts,js,mjs,mts,cjs,cts}"];
+const IGNORE_NON_APP = [
+  "**/server/**",
+  "**/scripts/**",
+  "**/packages/**",
+  "**/*.{config,test,spec}.*",
+  "**/*.d.ts"
+];
+const recommendedRules$2 = nuxtPlugin.configs.recommended.rules ?? {};
+function nuxtConfig(ctx, axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  const configs = [
+    {
+      // Secret leakage is a correctness/security floor — on at every variant.
+      name: "nustack/nuxt/runtime-config",
+      files: GLOB_NUXT_CONFIG,
+      plugins: { "@nustack/nuxt": nuxtPlugin },
+      rules: {
+        "@nustack/nuxt/no-secret-in-public-runtimeconfig": "error"
+      }
+    }
+  ];
+  if (variantAtLeast(axes.variant, "recommended")) {
+    configs.push(
+      {
+        name: "nustack/nuxt/auto-imports",
+        files: GLOB_APP$2,
+        ignores: IGNORE_NON_APP,
+        plugins: { "@nustack/nuxt": nuxtPlugin },
+        rules: {
+          ...recommendedRules$2,
+          "@nustack/nuxt/no-process-env": "off",
+          "@nustack/nuxt/no-secret-in-public-runtimeconfig": "off",
+          "@nustack/nuxt/no-explicit-auto-import": ["error", {
+            imports: ctx.autoImports,
+            components: ctx.components
+          }]
+        }
+      },
+      {
+        name: "@nustack/nuxt/no-process-env",
+        files: GLOB_APP$2,
+        // process.env is legitimate in build/server config; only flag app code.
+        ignores: IGNORE_NON_APP,
+        plugins: { "@nustack/nuxt": nuxtPlugin },
+        rules: {
+          "@nustack/nuxt/no-process-env": recommendedRules$2["@nustack/nuxt/no-process-env"]
+        }
+      }
+    );
+  }
+  if (Object.keys(rules).length) {
+    configs.push({
+      name: "nustack/nuxt/rules",
+      files: GLOB_APP$2,
+      rules
+    });
+  }
+  return configs;
+}
+
+const uiRules = nuxtEcosystemPlugin.configs.ui.rules ?? {};
+function nuxtUiConfig(_ctx, _axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  return [
+    {
+      name: "nustack/nuxt-ui",
+      files: ["**/*.vue"],
+      plugins: { "@nustack/nuxt-ui": nuxtEcosystemPlugin },
+      rules: {
+        ...uiRules,
+        ...rules
+      }
+    }
+  ];
+}
+
+const GLOB_CODE = ["**/*.vue", "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"];
+function tailwindConfig(ctx, axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  const uiAttributes = ctx.modules.nuxtUi ? [
+    // Bound `:ui` — better-tailwindcss normalizes it to `v-bind:ui`;
+    // the leading `:` in the config name is the signal it does so.
+    [":ui", [{ match: MatcherType.ObjectValue }]],
+    ["ui", [{ match: MatcherType.ObjectValue }]]
+  ] : [];
+  const entryPoint = opts.entryPoint ?? ctx.tailwind.entryPoint;
+  return [
+    {
+      name: "nustack/tailwind",
+      files: GLOB_CODE,
+      plugins: { "better-tailwindcss": betterTailwind },
+      settings: {
+        "better-tailwindcss": defu(opts.settings, {
+          ...entryPoint ? { entryPoint } : {},
+          attributes: [...getDefaultAttributes(), ...uiAttributes],
+          callees: getDefaultCallees()
+        })
+      },
+      rules: {
+        "better-tailwindcss/enforce-consistent-class-order": "warn",
+        ...variantAtLeast(axes.variant, "pedantic") ? { "better-tailwindcss/enforce-consistent-line-wrapping": "warn" } : {},
+        "better-tailwindcss/no-unregistered-classes": "warn",
+        "better-tailwindcss/no-conflicting-classes": "error",
+        "better-tailwindcss/no-duplicate-classes": "error",
+        ...rules
+      }
+    }
+  ];
+}
+
+function typeAwareConfig() {
+  return [
+    {
+      name: "nustack/type-aware",
+      files: ["**/*.{ts,tsx,mts,cts}", "**/*.vue"],
+      languageOptions: {
+        parserOptions: {
+          projectService: true
+        }
+      },
+      rules: {
+        // Surfaces usage of APIs marked `@deprecated` — a headline full-depth check.
+        "ts/no-deprecated": "warn"
+      }
+    }
+  ];
+}
+
+const GLOB_APP$1 = ["**/*.vue", "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"];
+const IGNORE_NON_CLIENT$1 = [
+  "**/server/**",
+  "**/scripts/**",
+  "**/packages/**",
+  "**/*.{config,test,spec}.*",
+  "**/*.d.ts"
+];
+const recommendedRules$1 = vitePlugin.configs.recommended.rules ?? {};
+function viteConfig(axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  const configs = [];
+  if (variantAtLeast(axes.variant, "recommended")) {
+    configs.push({
+      name: "nustack/vite",
+      files: GLOB_APP$1,
+      ignores: IGNORE_NON_CLIENT$1,
+      plugins: { "@nustack/vite": vitePlugin },
+      rules: recommendedRules$1
+    });
+  }
+  if (Object.keys(rules).length) {
+    configs.push({
+      name: "nustack/vite/rules",
+      files: GLOB_APP$1,
+      ignores: IGNORE_NON_CLIENT$1,
+      rules
+    });
+  }
+  return configs;
+}
+
+function vueConfig(_ctx, _axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  return [
+    {
+      name: "nustack/vue",
+      files: ["**/*.vue"],
+      rules: {
+        "vue/block-lang": ["error", {
+          script: { lang: "ts", allowNoLang: false }
+        }],
+        ...variantAtLeast(_axes.variant, "recommended") ? {
+          "vue/define-emits-declaration": ["warn", "type-literal"],
+          "vue/define-props-destructuring": ["warn", {
+            destructure: "always"
+          }],
+          "vue/html-comment-content-newline": "warn",
+          "vue/html-comment-indent": "warn",
+          "vue/no-duplicate-class-names": "warn",
+          "vue/no-empty-component-block": "warn",
+          "vue/no-import-compiler-macros": "error"
+        } : {},
+        ...rules
+      }
+    }
+  ];
+}
+
+const GLOB_APP = ["**/*.vue", "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"];
+const IGNORE_NON_CLIENT = [
+  "**/server/**",
+  "**/scripts/**",
+  "**/packages/**",
+  "**/*.{config,test,spec}.*",
+  "**/*.d.ts"
+];
+const recommendedRules = vueUsePlugin.configs.recommended.rules ?? {};
+function vueUseConfig(axes, opts = {}) {
+  const rules = resolveConcernRules(opts);
+  const configs = [];
+  if (variantAtLeast(axes.variant, "recommended")) {
+    configs.push({
+      name: "nustack/vueuse",
+      files: GLOB_APP,
+      ignores: IGNORE_NON_CLIENT,
+      plugins: { "@nustack/vueuse": vueUsePlugin },
+      rules: recommendedRules
+    });
+  }
+  if (Object.keys(rules).length) {
+    configs.push({
+      name: "nustack/vueuse/rules",
+      files: GLOB_APP,
+      ignores: IGNORE_NON_CLIENT,
+      rules
+    });
+  }
+  return configs;
+}
+
+const EMPTY_CONTEXT = {
+  modules: { nuxtUi: false, pinia: false, nuxtImage: false, nuxtContent: false },
+  tailwind: { detected: false, entryPoint: null },
+  autoImports: [],
+  components: []
+};
+
+function resolveDepth() {
+  return process.env.NUSTACK_LINT_DEPTH === "full" ? "full" : "quick";
+}
+function mergeContext(context) {
+  return defu(context, EMPTY_CONTEXT);
+}
+function isEnabled(toggle, gate) {
+  if (toggle === false)
+    return false;
+  if (toggle === true || typeof toggle === "object" && toggle !== null)
+    return true;
+  return gate;
+}
+function subOptions(toggle) {
+  return typeof toggle === "object" && toggle !== null ? toggle : {};
+}
+function resolveRules(options) {
+  return {
+    ...options.overrides,
+    ...options.rules
+  };
+}
+function applyNustackConfig(base, options = {}, ...userConfigs) {
+  const variant = options.variant ?? "recommended";
+  const depth = resolveDepth();
+  const ctx = mergeContext(options.context);
+  const axes = { variant};
+  const antfu = antfuBase(options.base, depth);
+  if (antfu)
+    base.prepend(antfu);
+  const configs = [];
+  if (isEnabled(options.nuxt, true))
+    configs.push(...nuxtConfig(ctx, axes, subOptions(options.nuxt)));
+  if (isEnabled(options.vue, true))
+    configs.push(...vueConfig(ctx, axes, subOptions(options.vue)));
+  if (isEnabled(options.vueUse, true))
+    configs.push(...vueUseConfig(axes, subOptions(options.vueUse)));
+  if (isEnabled(options.vite, true))
+    configs.push(...viteConfig(axes, subOptions(options.vite)));
+  if (isEnabled(options.tailwind, ctx.tailwind.detected))
+    configs.push(...tailwindConfig(ctx, axes, subOptions(options.tailwind)));
+  if (isEnabled(options.nuxtUi, ctx.modules.nuxtUi))
+    configs.push(...nuxtUiConfig(ctx, axes, subOptions(options.nuxtUi)));
+  if (depth === "full")
+    configs.push(...typeAwareConfig());
+  const rules = resolveRules(options);
+  if (Object.keys(rules).length) {
+    configs.push({
+      name: "nustack/rules",
+      rules
+    });
+  }
+  return base.append(...configs, ...userConfigs);
+}
+function nustack(options = {}, ...userConfigs) {
+  return applyNustackConfig(composer(), {
+    nuxt: false,
+    nuxtUi: false,
+    vite: false,
+    vueUse: false,
+    ...options,
+    context: options.context ?? EMPTY_CONTEXT
+  }, ...userConfigs);
+}
+
+export { EMPTY_CONTEXT, applyNustackConfig, nustack as default, nustack };

package/dist/module.d.mts

@@ -0,0 +1,14 @@
+import * as _nuxt_schema from '@nuxt/schema';
+export { N as NustackContext } from './shared/lint.Cq_cclOu.mjs';
+
+/**
+ * Options are intentionally empty: `@nustackjs/lint` is zero-config. It auto-detects
+ * the project's modules, auto-imports, components and Tailwind entry point, and
+ * activates the matching rule packs automatically.
+ */
+interface ModuleOptions {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@nustackjs/lint",
+  "configKey": "@nustackjs/lint",
+  "version": "0.0.1",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,140 @@
+import { resolveAlias, defineNuxtModule, installModule } from '@nuxt/kit';
+import { defu } from 'defu';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { join, dirname, relative } from 'node:path';
+
+const TAILWIND_IMPORT_RE = /@import\s+["']tailwindcss["']/;
+const MODULE_FLAGS = {
+  "@nuxt/ui": "nuxtUi",
+  "@nuxt/ui-pro": "nuxtUi",
+  "@pinia/nuxt": "pinia",
+  "@nuxt/image": "nuxtImage",
+  "@nuxt/content": "nuxtContent"
+};
+function setupNustackContext(nuxt) {
+  let unimport;
+  let nitroUnimport;
+  let components = [];
+  nuxt.hook("imports:context", (ctx) => {
+    unimport = ctx;
+  });
+  nuxt.hook("nitro:init", (nitro) => {
+    nitroUnimport = nitro.unimport;
+  });
+  nuxt.hook("components:extend", (list) => {
+    components = [...new Set(list.map((c) => c.pascalName))].sort();
+  });
+  async function collectAutoImports() {
+    const imports = [
+      ...await unimport?.getImports() ?? [],
+      ...await nitroUnimport?.getImports() ?? []
+    ];
+    const names = imports.filter((i) => !i.type).map((i) => i.as || i.name).filter((name) => Boolean(name));
+    return [...new Set(names)].sort();
+  }
+  function detectModules() {
+    const installed = /* @__PURE__ */ new Set();
+    for (const m of nuxt.options._installedModules ?? []) {
+      const name = m.meta?.name;
+      if (name)
+        installed.add(name);
+    }
+    for (const m of nuxt.options.modules ?? []) {
+      if (typeof m === "string")
+        installed.add(m);
+    }
+    const modules = {
+      nuxtUi: false,
+      pinia: false,
+      nuxtImage: false,
+      nuxtContent: false
+    };
+    for (const [name, flag] of Object.entries(MODULE_FLAGS)) {
+      if (installed.has(name))
+        modules[flag] = true;
+    }
+    return modules;
+  }
+  async function detectTailwind() {
+    for (const entry of nuxt.options.css ?? []) {
+      if (typeof entry !== "string" || !entry.endsWith(".css"))
+        continue;
+      const abs = resolveAlias(entry, nuxt.options.alias);
+      if (!existsSync(abs))
+        continue;
+      try {
+        const source = await readFile(abs, "utf-8");
+        if (TAILWIND_IMPORT_RE.test(source)) {
+          return {
+            detected: true,
+            // better-tailwindcss resolves `entryPoint` relative to the lint cwd
+            // (the project root), so store it relative to rootDir.
+            entryPoint: relative(nuxt.options.rootDir, abs)
+          };
+        }
+      } catch {
+      }
+    }
+    return { detected: false, entryPoint: null };
+  }
+  async function buildContext() {
+    return {
+      modules: detectModules(),
+      tailwind: await detectTailwind(),
+      autoImports: await collectAutoImports(),
+      components
+    };
+  }
+  async function writeContextFile() {
+    const context = await buildContext();
+    const file = join(nuxt.options.buildDir, "nustack-eslint.mjs");
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, generateCode(context), "utf-8");
+  }
+  nuxt.hook("builder:generateApp", writeContextFile);
+}
+function generateCode(context) {
+  return [
+    "// Generated by @nustackjs/lint \u2014 do not edit.",
+    "// Regenerated on every `nuxt prepare`.",
+    `import { applyNustackConfig as factory } from '@nustackjs/lint/config'`,
+    `import withNuxt from './eslint.config.mjs'`,
+    "",
+    `export const nustackContext = ${JSON.stringify(context, null, 2)}`,
+    "",
+    "/**",
+    " * Project-aware ESLint config, with `withNuxt()` already wired in. Pass one",
+    " * options object, then optional flat config objects. Returns the composer, so",
+    " * you can chain `.append()` / `.override()` / `.remove()` as an escape hatch.",
+    " */",
+    "export function nustack(options = {}, ...configs) {",
+    "  return factory(withNuxt(), { ...options, context: nustackContext }, ...configs)",
+    "}",
+    "",
+    "export const nustackLint = nustack",
+    "",
+    "// Default export = the ready-to-use config, so `export { default } from` works.",
+    "export default nustack()",
+    ""
+  ].join("\n");
+}
+
+function hasModule(nuxt, name) {
+  return nuxt.options.modules.some((m) => (Array.isArray(m) ? m[0] : m) === name);
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@nustackjs/lint"
+  },
+  defaults: {},
+  async setup(_options, nuxt) {
+    nuxt.options.eslint = defu(nuxt.options.eslint, { config: {} });
+    nuxt.options.eslint.config.standalone = false;
+    if (!hasModule(nuxt, "@nuxt/eslint"))
+      await installModule("@nuxt/eslint");
+    setupNustackContext(nuxt);
+  }
+});
+
+export { module$1 as default };

package/dist/shared/lint.Cq_cclOu.d.mts

@@ -0,0 +1,41 @@
+/**
+ * Shape of the project context that the Nuxt module resolves at `nuxt prepare`
+ * time and serializes into `.nuxt/nustack-eslint.mjs`. The ESLint config factory
+ * (`nustack`) reads this back to decide which rule packs to activate, so the
+ * lint config always matches what the project actually uses — zero config.
+ */
+interface NustackContext {
+    /** Detected Nuxt modules that have a dedicated rule pack. */
+    modules: {
+        /** `@nuxt/ui` — activates the Tailwind + Nuxt UI pack. */
+        nuxtUi: boolean;
+        /** `@pinia/nuxt` — reserved for a future pack. */
+        pinia: boolean;
+        /** `@nuxt/image` — contributes auto-imported components. */
+        nuxtImage: boolean;
+        /** `@nuxt/content` — reserved for a future pack. */
+        nuxtContent: boolean;
+    };
+    tailwind: {
+        /** Whether a Tailwind v4 CSS entry point was found. */
+        detected: boolean;
+        /**
+         * Path to the CSS file that imports Tailwind (`@import "tailwindcss"`),
+         * relative to the project root. `null` when not detected.
+         */
+        entryPoint: string | null;
+    };
+    /**
+     * Every identifier Nuxt makes globally available without an explicit import,
+     * pulled from the resolved unimport registry (Vue reactivity, Nuxt
+     * composables, project `composables/` + `utils/`, module-provided helpers).
+     */
+    autoImports: string[];
+    /** Globally registered component names (Nuxt built-ins + project + modules). */
+    components: string[];
+}
+/** A safe, empty context used as a fallback when the generated file is absent. */
+declare const EMPTY_CONTEXT: NustackContext;
+
+export { EMPTY_CONTEXT as E };
+export type { NustackContext as N };

package/dist/types.d.mts

@@ -0,0 +1,5 @@
+export { type NustackContext } from './shared/lint.Cq_cclOu.mjs'
+
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@nustackjs/lint",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Zero-config, project-aware ESLint (oxlint-ready) for Nuxt — plug it in and catch Nuxt bugs, not just style.",
+  "author": "Norbiros <me@norbiros.dev>",
+  "license": "MIT",
+  "homepage": "https://github.com/Zerya-Dev/nustack/tree/master/modules/lint#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Zerya-Dev/nustack.git",
+    "directory": "modules/lint"
+  },
+  "keywords": [
+    "eslint",
+    "oxlint",
+    "nuxt",
+    "nustack",
+    "lint",
+    "vue"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./config": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/module.d.mts"
+      ],
+      "config": [
+        "./dist/index.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "LICENSE",
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "nuxt": ">=3.0.0"
+  },
+  "dependencies": {
+    "@antfu/eslint-config": "^9.0.0",
+    "@nustackjs/lint-plugin-nuxt": "^0.0.1",
+    "@nustackjs/lint-plugin-nuxt-ecosystem": "^0.0.1",
+    "@nustackjs/lint-plugin-vite": "^0.0.1",
+    "@nustackjs/lint-plugin-vueuse": "^0.0.1",
+    "@nuxt/eslint": "^1.15.2",
+    "@nuxt/kit": "^4.4.7",
+    "@typescript-eslint/utils": "^8.60.1",
+    "defu": "^6.1.7",
+    "eslint-flat-config-utils": "^3.2.0",
+    "eslint-plugin-better-tailwindcss": "^3.7.10",
+    "eslint-plugin-vue": "^10.5.0",
+    "unimport": "^6.3.0",
+    "vue-eslint-parser": "^10.4.1"
+  },
+  "devDependencies": {
+    "@eslint/config-inspector": "^1.5.0",
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/eslint-config": "^1.15.2",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.7",
+    "@nuxt/test-utils": "^4.0.3",
+    "@types/node": "latest",
+    "@typescript-eslint/parser": "^8.60.1",
+    "@typescript-eslint/rule-tester": "^8.60.1",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.4.1",
+    "nuxt": "^4.4.7",
+    "tailwindcss": "^4.0.0",
+    "typescript": "~6.0.3",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.1.8",
+    "vue-tsc": "^3.3.3"
+  },
+  "scripts": {
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "pnpm --filter '@nustackjs/lint-plugin-*' build && nuxt-module-build build && nuxt-module-build prepare && nuxt prepare playground",
+    "dev:inspector": "npx @eslint/config-inspector --config eslint.config.ts",
+    "build:inspector": "npx @eslint/config-inspector build --config eslint.config.ts --out-dir ./.eslint-config-inspector",
+    "lint": "eslint .",
+    "test": "pnpm --filter '@nustackjs/lint-plugin-*' build && vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  }
+}