@theglitchking/gimme-the-lint 2.4.0 → 2.5.0

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.0"
   },
   "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.0",
       "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.0",
   "author": {
     "name": "TheGlitchKing",
     "email": "theglitchking@users.noreply.github.com"

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.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/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.0",
   "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",