@theglitchking/gimme-the-lint 2.4.0 → 2.5.1

package/.claude-plugin/marketplace.json

@@ -6,13 +6,13 @@
   },
   "metadata": {
     "description": "Official marketplace for gimme-the-lint - polyglot progressive linting with per-app baselines and drift detection",
-    "version": "2.4.0"
+    "version": "2.5.1"
   },
   "plugins": [
     {
       "name": "gimme-the-lint",
       "description": "Polyglot progressive linting for monorepos — adapter-driven baselines, per-app drift detection, and idempotent skips across JavaScript/TypeScript, Python, Go, Rust, Terraform, and Ansible.",
-      "version": "2.4.0",
+      "version": "2.5.1",
       "author": {
         "name": "TheGlitchKing"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gimme-the-lint",
   "description": "Polyglot progressive linting for monorepos — adapter-driven baselines, per-app drift detection, and idempotent skips across JavaScript/TypeScript, Python, Go, Rust, Terraform, and Ansible.",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "author": {
     "name": "TheGlitchKing",
     "email": "theglitchking@users.noreply.github.com"

package/CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.1] - 2026-05-17
+
+### Fixed
+- **tflint config resolution is now root-aware.** In the standard Terraform
+  monorepo — one repo-root `.tflint.hcl`, many nested `modules/*` / `envs/*`
+  units — the adapter resolved config only in the unit directory, so every
+  unit was linted with tflint defaults: the repo's preset, plugin declarations
+  and `rule { enabled = false }` overrides were silently ignored and
+  `tflint --init` never ran. Meanwhile `configHashFor()` *did* find the
+  repo-root config, so the baseline's `config_hash` reflected a config the
+  linter never actually used — a silent correctness bug. A new shared resolver,
+  `LinterAdapter.resolveConfigPath()`, walks up from the unit directory to the
+  project root; `buildCommand()` and `initCommand()` now pass the resolved
+  file as an absolute `--config`, and `configHashFor()` hashes that same file —
+  the hashed config and the linted config can no longer disagree. A unit with
+  its own `.tflint.hcl` still wins (nearest-first); a repo with no config
+  anywhere still runs the zero-config core ruleset. The resolver is generic
+  (no provider name in code) and root-aware config-hashing now benefits every
+  adapter.
+
+## [2.5.0] - 2026-05-17
+
+### Added
+- **`.gtl/config.js` — consolidated config location.** gimme-the-lint's own
+  config file now lives canonically at `.gtl/config.js` (`.gtl/config.cjs` for
+  ESM projects), so it travels with the committed `.gtl/` baselines rather than
+  sitting loose at the repo root. `install` and `migrate` write new configs
+  there; `config-manager.findConfig()` resolves the location. A repo-root
+  `gimme-the-lint.config.js` is still read as a fallback — existing projects
+  need no change — and `.gtl/` wins when both exist. `uninstall` removes a
+  repo-root config but leaves a `.gtl/` one in place (it is part of the
+  preserved `.gtl/` directory). Linter configs (`eslint.config.js`,
+  `.tflint.hcl`, …) are unaffected: each linter resolves its own config from a
+  fixed location gimme-the-lint does not own.
+
 ## [2.4.0] - 2026-05-17
 
 ### Fixed

package/README.md

@@ -173,7 +173,10 @@ git add -A && git commit -m "…" # retry
 ## Configuration
 
 Zero config is the default — apps and their linters are auto-detected. To
-override, add `gimme-the-lint.config.js` at the repo root:
+override, add a config file. The canonical location is **`.gtl/config.js`**
+(it travels with the committed `.gtl/` baselines); a repo-root
+`gimme-the-lint.config.js` is also read, for back-compatibility. `install` and
+`migrate` write new configs to `.gtl/`:
 
 ```js
 module.exports = {

package/bin/gimme-the-lint.js

@@ -86,6 +86,7 @@ program
   .action(async () => {
     const chalk = require('chalk');
     const gitHooksManager = require('../lib/git-hooks-manager');
+    const configManager = require('../lib/config-manager');
 
     console.log(chalk.blue('\ngimme-the-lint: Uninstalling...\n'));
 
@@ -94,10 +95,17 @@ program
       console.log(chalk.green(`  ✓ Removed git hooks: ${removed.join(', ')}`));
     }
 
-    const configPath = path.join(process.cwd(), 'gimme-the-lint.config.js');
-    if (fs.existsSync(configPath)) {
-      fs.unlinkSync(configPath);
-      console.log(chalk.green('  ✓ Removed gimme-the-lint.config.js'));
+    // Remove a repo-root config. A config under .gtl/ is left in place — it is
+    // part of the .gtl/ directory, which uninstall preserves.
+    const cfgPath = configManager.findConfig(process.cwd());
+    if (cfgPath) {
+      const rel = path.relative(process.cwd(), cfgPath);
+      if (rel.startsWith(`.gtl${path.sep}`)) {
+        console.log(chalk.dim(`  · Config kept (${rel} — part of .gtl/)`));
+      } else {
+        fs.unlinkSync(cfgPath);
+        console.log(chalk.green(`  ✓ Removed ${path.basename(cfgPath)}`));
+      }
     }
 
     console.log(chalk.green('\n✓ Uninstall complete.\n'));
@@ -372,7 +380,7 @@ program
     const projectType = await configManager.detectProjectType(projectRoot);
     const venvStatus = venvManager.getStatus(projectRoot);
     const hookStatus = await gitHooksManager.getStatus(projectRoot);
-    const configExists = fs.existsSync(path.join(projectRoot, 'gimme-the-lint.config.js'));
+    const configExists = Boolean(configManager.findConfig(projectRoot));
 
     console.log(chalk.blue('\ngimme-the-lint Status\n'));
     console.log(`  Project type:  ${projectType}`);

package/lib/adapters/adapter.js

@@ -65,6 +65,38 @@ class LinterAdapter {
     return [];
   }
 
+  /**
+   * Resolve the EFFECTIVE config file for the unit being linted: walk up from
+   * `startDir` (default: appRoot) to projectRoot inclusive and return the
+   * absolute path of the nearest file named by configFiles(), or null if none
+   * exists anywhere on that path.
+   *
+   * Root-aware — this is what lets a single repo-root config (the standard
+   * monorepo layout: one config, many nested units) govern every unit. It is
+   * the SINGLE source of truth shared by the config-hash (baseline.js) and the
+   * linter invocation, so the hashed config and the linted config can never
+   * disagree.
+   * @param {string} [startDir]
+   * @returns {string|null}
+   */
+  resolveConfigPath(startDir) {
+    const names = this.configFiles();
+    if (!names || names.length === 0) return null;
+    const root = path.resolve(this.projectRoot);
+    let dir = path.resolve(startDir || this.appRoot);
+    while (true) {
+      for (const name of names) {
+        const candidate = path.join(dir, name);
+        if (fs.existsSync(candidate)) return candidate;
+      }
+      if (dir === root) break; // checked projectRoot — stop
+      const parent = path.dirname(dir);
+      if (parent === dir) break; // filesystem root reached
+      dir = parent;
+    }
+    return null;
+  }
+
   /** Return the first candidate path that exists, else the last candidate. */
   resolveBinary(candidates) {
     for (const candidate of candidates) {

package/lib/adapters/tflint.js

@@ -66,16 +66,22 @@ class TflintAdapter extends LinterAdapter {
 
   // --- .tflint.hcl introspection (generic — no provider is special-cased) ---
 
-  /** True when the unit directory carries a .tflint.hcl. */
+  /** True when an effective .tflint.hcl exists (the unit dir or up to root). */
   _hasConfig(dir) {
-    return fs.existsSync(path.join(dir || this.appRoot, '.tflint.hcl'));
+    return this.resolveConfigPath(dir) !== null;
   }
 
-  /** Enumerate every `plugin "<name>"` block declared in a unit's .tflint.hcl. */
+  /**
+   * Enumerate every `plugin "<name>"` block in the EFFECTIVE .tflint.hcl —
+   * the one resolveConfigPath() resolves, which may live up at the repo root,
+   * not in the unit dir.
+   */
   _declaredPlugins(dir) {
+    const configPath = this.resolveConfigPath(dir);
+    if (!configPath) return [];
     let hcl;
     try {
-      hcl = fs.readFileSync(path.join(dir || this.appRoot, '.tflint.hcl'), 'utf8');
+      hcl = fs.readFileSync(configPath, 'utf8');
     } catch {
       return [];
     }
@@ -105,10 +111,12 @@ class TflintAdapter extends LinterAdapter {
    * base adapter). A repo with no .tflint.hcl gets core linting, no init.
    */
   initCommand(cwd) {
-    if (this._hasConfig(cwd)) {
-      return { cmd: this.binary, args: ['--init'] };
-    }
-    return null;
+    const configPath = this.resolveConfigPath(cwd);
+    if (!configPath) return null;
+    // Pass the resolved config explicitly so `--init` reads the right
+    // .tflint.hcl for its plugin declarations — even when it lives up at the
+    // repo root rather than in the unit dir.
+    return { cmd: this.binary, args: ['--init', `--config=${configPath}`] };
   }
 
   // --- availability: agree with what lint() will actually see --------------
@@ -178,6 +186,14 @@ class TflintAdapter extends LinterAdapter {
         // Unresolvable target — fall back to the default cwd.
       }
     }
+
+    // tflint runs IN the unit dir; pass the effective config — which may live
+    // up at the repo root — as an absolute --config so the unit is linted with
+    // the repo's preset / plugin declarations / rule overrides, not tflint
+    // defaults. No config anywhere → plain tflint (zero-config core ruleset).
+    const configPath = this.resolveConfigPath(cwd);
+    if (configPath) args.push(`--config=${configPath}`);
+
     return { cmd: this.binary, args, cwd };
   }
 

package/lib/baseline.js

@@ -18,15 +18,17 @@ const gtlManifest = require('./gtl-manifest');
 // the baseline CLI, the hooks installer) can refuse to gate commits against a
 // baseline that never actually captured a linter.
 
-/** Hash the first config file found for an adapter (unit root, then project). */
+/**
+ * Hash the EFFECTIVE config file for an adapter. Resolution walks up from the
+ * unit dir to the project root via the adapter's shared resolver, so the
+ * hashed config is exactly the one the linter is invoked with — a repo-root
+ * config governing nested units is hashed correctly, never missed or faked.
+ */
+// eslint-disable-next-line no-unused-vars
 async function configHashFor(projectRoot, unitRoot, adapter) {
-  for (const name of adapter.configFiles()) {
-    for (const base of [unitRoot, projectRoot]) {
-      const hash = await manifestManager.hashFile(path.join(base, name));
-      if (hash !== 'unknown') return hash;
-    }
-  }
-  return 'unknown';
+  const configPath = adapter.resolveConfigPath(unitRoot);
+  if (!configPath) return 'unknown';
+  return manifestManager.hashFile(configPath);
 }
 
 /** Baseline a single unit across all its bound linters. */

package/lib/config-manager.js

@@ -38,9 +38,49 @@ async function detectProjectType(projectRoot) {
   return 'unknown';
 }
 
+// Config-file lookup order. The .gtl/ location is canonical — the config
+// travels with the committed .gtl/ baselines and keeps gimme-the-lint's own
+// files in one place. The repo-root location is retained as a fallback so
+// projects created before this layout keep working with no change.
+const CONFIG_CANDIDATES = [
+  ['.gtl', 'config.cjs'],
+  ['.gtl', 'config.js'],
+  ['gimme-the-lint.config.cjs'],
+  ['gimme-the-lint.config.js'],
+];
+
+/** Absolute path of the project's gimme-the-lint config, or null if none. */
+function findConfig(projectRoot) {
+  for (const parts of CONFIG_CANDIDATES) {
+    const candidate = path.join(projectRoot, ...parts);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Is the target project ESM ("type": "module" in package.json)? */
+async function isESMProject(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (await fs.pathExists(pkgPath)) {
+    try {
+      return JSON.parse(await fs.readFile(pkgPath, 'utf8')).type === 'module';
+    } catch {
+      /* unreadable package.json — treat as CommonJS */
+    }
+  }
+  return false;
+}
+
+/**
+ * Where a NEW config is written — the canonical .gtl/ location. ESM projects
+ * get a .cjs extension so `require()` of the CommonJS config still works.
+ */
+async function newConfigPath(projectRoot) {
+  const esm = await isESMProject(projectRoot);
+  return path.join(projectRoot, '.gtl', esm ? 'config.cjs' : 'config.js');
+}
+
 function getConfig(projectRoot) {
-  const cjsPath = path.join(projectRoot, 'gimme-the-lint.config.cjs');
-  const jsPath = path.join(projectRoot, 'gimme-the-lint.config.js');
   const defaults = {
     frontendDir: 'frontend',
     backendDir: 'backend',
@@ -52,7 +92,7 @@ function getConfig(projectRoot) {
     testExcludedBackend: ['tests', '*test*', '__pycache__'],
   };
 
-  const configPath = fs.existsSync(cjsPath) ? cjsPath : fs.existsSync(jsPath) ? jsPath : null;
+  const configPath = findConfig(projectRoot);
   if (configPath) {
     try {
       const userConfig = require(configPath);
@@ -66,26 +106,19 @@ function getConfig(projectRoot) {
 }
 
 async function initConfig(projectRoot, options = {}) {
-  const cjsPath = path.join(projectRoot, 'gimme-the-lint.config.cjs');
-  const jsPath = path.join(projectRoot, 'gimme-the-lint.config.js');
+  const existing = findConfig(projectRoot);
 
-  // Don't overwrite if either variant already exists
-  if (!options.force && (await fs.pathExists(cjsPath) || await fs.pathExists(jsPath))) {
-    const existing = await fs.pathExists(cjsPath) ? cjsPath : jsPath;
+  // Don't overwrite an existing config (wherever it lives).
+  if (!options.force && existing) {
     return { created: false, path: existing };
   }
 
-  // Detect if the target project uses ESM ("type": "module" in package.json)
-  let isESM = false;
-  const pkgPath = path.join(projectRoot, 'package.json');
-  if (await fs.pathExists(pkgPath)) {
-    try {
-      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
-      isESM = pkg.type === 'module';
-    } catch {}
-  }
+  // New config → the canonical .gtl/ location. --force overwrites in place,
+  // so a legacy repo-root config is never silently shadowed by a .gtl/ one.
+  const configPath = existing && options.force
+    ? existing
+    : await newConfigPath(projectRoot);
 
-  const configPath = isESM ? cjsPath : jsPath;
   const projectType = await detectProjectType(projectRoot);
   const config = {
     projectType,
@@ -100,36 +133,26 @@ async function initConfig(projectRoot, options = {}) {
 module.exports = ${JSON.stringify(config, null, 2)};
 `;
 
+  await fs.ensureDir(path.dirname(configPath));
   await fs.writeFile(configPath, content, 'utf8');
   return { created: true, path: configPath, projectType };
 }
 
 /**
- * Write an explicit `apps` map into gimme-the-lint.config.js so the discovered
- * app/linter layout is visible and editable instead of silently re-guessed on
- * every run. Never overwrites an existing config.
+ * Write an explicit `apps` map into the gimme-the-lint config so the
+ * discovered app/linter layout is visible and editable instead of silently
+ * re-guessed on every run. Never overwrites an existing config; a new one is
+ * written to the canonical .gtl/ location.
  * @param {string} projectRoot
  * @param {{appPath: string, linters: string[]}[]} apps
  */
 async function writeAppsConfig(projectRoot, apps) {
-  const cjsPath = path.join(projectRoot, 'gimme-the-lint.config.cjs');
-  const jsPath = path.join(projectRoot, 'gimme-the-lint.config.js');
-  if ((await fs.pathExists(cjsPath)) || (await fs.pathExists(jsPath))) {
-    return {
-      created: false,
-      path: (await fs.pathExists(cjsPath)) ? cjsPath : jsPath,
-    };
-  }
-
-  let isESM = false;
-  const pkgPath = path.join(projectRoot, 'package.json');
-  if (await fs.pathExists(pkgPath)) {
-    try {
-      isESM = JSON.parse(await fs.readFile(pkgPath, 'utf8')).type === 'module';
-    } catch {}
+  const existing = findConfig(projectRoot);
+  if (existing) {
+    return { created: false, path: existing };
   }
-  const configPath = isESM ? cjsPath : jsPath;
 
+  const configPath = await newConfigPath(projectRoot);
   const appsObj = {};
   for (const app of apps || []) {
     appsObj[app.appPath] = { linters: app.linters };
@@ -139,6 +162,7 @@ async function writeAppsConfig(projectRoot, apps) {
 // Edit this map to correct any mis-discovered apps or linters.
 module.exports = ${JSON.stringify({ apps: appsObj }, null, 2)};
 `;
+  await fs.ensureDir(path.dirname(configPath));
   await fs.writeFile(configPath, content, 'utf8');
   return { created: true, path: configPath, apps: appsObj };
 }
@@ -146,6 +170,7 @@ module.exports = ${JSON.stringify({ apps: appsObj }, null, 2)};
 module.exports = {
   copyTemplate,
   detectProjectType,
+  findConfig,
   getConfig,
   initConfig,
   writeAppsConfig,

package/lib/installer.js

@@ -33,7 +33,11 @@ async function init(projectRoot, options = {}) {
     frontendDir: options.frontendDir,
     backendDir: options.backendDir,
   });
-  results.steps.push(configResult.created ? `Created ${path.basename(configResult.path)}` : 'Config already exists');
+  results.steps.push(
+    configResult.created
+      ? `Created ${path.relative(projectRoot, configResult.path)}`
+      : `Config already exists (${path.relative(projectRoot, configResult.path)})`
+  );
 
   // Step 3: Copy ESLint template (frontend)
   if (enableFrontend) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theglitchking/gimme-the-lint",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Polyglot progressive linting for monorepos — adapter-driven baselines, per-app drift detection, and idempotent skips across JavaScript/TypeScript, Python, Go, Rust, Terraform, and Ansible.",
   "keywords": [
     "linting",