@theglitchking/gimme-the-lint 1.0.0

package/lib/drift-detector.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const manifestManager = require('./manifest-manager');
+
+async function detectDrift({ manifestPath, configPath, currentDirs }) {
+  const manifest = await manifestManager.readManifest(manifestPath);
+  if (!manifest) {
+    return { noManifest: true, message: 'No manifest found - run baseline first' };
+  }
+
+  const drift = {
+    hasDirectoryDrift: false,
+    hasConfigDrift: false,
+    hasTimeDrift: false,
+    hasViolationDrift: false,
+    addedDirs: [],
+    removedDirs: [],
+    age: 0,
+    details: [],
+  };
+
+  const baselineDirs = manifest.directories_baselined || [];
+  drift.addedDirs = currentDirs.filter((d) => !baselineDirs.includes(d));
+  drift.removedDirs = baselineDirs.filter((d) => !currentDirs.includes(d));
+  drift.hasDirectoryDrift = drift.addedDirs.length > 0 || drift.removedDirs.length > 0;
+
+  if (drift.addedDirs.length > 0) {
+    drift.details.push(`Added directories: ${drift.addedDirs.join(', ')}`);
+  }
+  if (drift.removedDirs.length > 0) {
+    drift.details.push(`Removed directories: ${drift.removedDirs.join(', ')}`);
+  }
+
+  const currentHash = await manifestManager.hashFile(configPath);
+  drift.hasConfigDrift = currentHash !== 'unknown' && currentHash !== manifest.config_hash;
+  if (drift.hasConfigDrift) {
+    drift.details.push('Configuration changed (config file hash mismatch)');
+  }
+
+  drift.age = manifestManager.calculateAge(manifest.created_at);
+  drift.hasTimeDrift = drift.age > 30;
+  if (drift.hasTimeDrift) {
+    drift.details.push(`Baseline is ${drift.age} days old (consider refreshing)`);
+  }
+
+  return drift;
+}
+
+function formatDriftReport(drift) {
+  if (drift.noManifest) {
+    return drift.message;
+  }
+
+  const hasDrift = drift.hasDirectoryDrift || drift.hasConfigDrift || drift.hasTimeDrift;
+  if (!hasDrift) {
+    return null;
+  }
+
+  const lines = ['Drift Detected:'];
+  for (const detail of drift.details) {
+    lines.push(`  - ${detail}`);
+  }
+  return lines.join('\n');
+}
+
+async function autoHeal({ manifestPath, configPath, currentDirs, tool, version, currentViolations, testExcluded }) {
+  const oldManifest = await manifestManager.readManifest(manifestPath);
+
+  const newManifest = await manifestManager.createManifest({
+    tool,
+    version,
+    directories: currentDirs,
+    violations: currentViolations,
+    configPath,
+    testExcluded,
+  });
+
+  await manifestManager.writeManifest(manifestPath, newManifest);
+
+  return {
+    oldDirs: oldManifest ? oldManifest.directories_baselined : [],
+    newDirs: currentDirs,
+    oldViolations: oldManifest ? oldManifest.total_violations : 0,
+    newViolations: currentViolations,
+  };
+}
+
+module.exports = {
+  detectDrift,
+  formatDriftReport,
+  autoHeal,
+};

package/lib/git-hooks-manager.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function getGitRoot(projectRoot) {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      cwd: projectRoot,
+      encoding: 'utf8',
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function getHooksDir(projectRoot) {
+  const gitRoot = getGitRoot(projectRoot);
+  if (!gitRoot) return null;
+  return path.join(gitRoot, '.git', 'hooks');
+}
+
+async function installHooks(projectRoot) {
+  const hooksDir = getHooksDir(projectRoot);
+  if (!hooksDir) {
+    throw new Error('Not a git repository. Run git init first.');
+  }
+
+  await fs.ensureDir(hooksDir);
+
+  const sourceHooksDir = path.join(__dirname, '..', 'githooks');
+  const hooks = ['pre-commit', 'pre-push'];
+  const installed = [];
+
+  for (const hook of hooks) {
+    const src = path.join(sourceHooksDir, hook);
+    const dest = path.join(hooksDir, hook);
+
+    if (!await fs.pathExists(src)) continue;
+
+    if (await fs.pathExists(dest)) {
+      const existing = await fs.readFile(dest, 'utf8');
+      if (!existing.includes('gimme-the-lint')) {
+        const backup = `${dest}.backup.${Date.now()}`;
+        await fs.copy(dest, backup);
+      }
+    }
+
+    await fs.copy(src, dest);
+    await fs.chmod(dest, 0o755);
+    installed.push(hook);
+  }
+
+  return installed;
+}
+
+async function uninstallHooks(projectRoot) {
+  const hooksDir = getHooksDir(projectRoot);
+  if (!hooksDir) return [];
+
+  const hooks = ['pre-commit', 'pre-push'];
+  const removed = [];
+
+  for (const hook of hooks) {
+    const hookPath = path.join(hooksDir, hook);
+    if (await fs.pathExists(hookPath)) {
+      const content = await fs.readFile(hookPath, 'utf8');
+      if (content.includes('gimme-the-lint')) {
+        await fs.remove(hookPath);
+
+        // Restore backup if exists
+        const backups = (await fs.readdir(hooksDir))
+          .filter((f) => f.startsWith(`${hook}.backup.`))
+          .sort()
+          .reverse();
+        if (backups.length > 0) {
+          await fs.move(path.join(hooksDir, backups[0]), hookPath);
+        }
+
+        removed.push(hook);
+      }
+    }
+  }
+
+  return removed;
+}
+
+async function getStatus(projectRoot) {
+  const hooksDir = getHooksDir(projectRoot);
+  if (!hooksDir) return { gitRepo: false, hooks: {} };
+
+  const hooks = ['pre-commit', 'pre-push'];
+  const status = {};
+
+  for (const hook of hooks) {
+    const hookPath = path.join(hooksDir, hook);
+    if (await fs.pathExists(hookPath)) {
+      const content = await fs.readFile(hookPath, 'utf8');
+      status[hook] = content.includes('gimme-the-lint') ? 'installed' : 'other';
+    } else {
+      status[hook] = 'missing';
+    }
+  }
+
+  return { gitRepo: true, hooks: status };
+}
+
+module.exports = {
+  getGitRoot,
+  getHooksDir,
+  installHooks,
+  uninstallHooks,
+  getStatus,
+};

package/lib/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const directoryDiscovery = require('./directory-discovery');
+const manifestManager = require('./manifest-manager');
+const driftDetector = require('./drift-detector');
+const venvManager = require('./venv-manager');
+const configManager = require('./config-manager');
+const gitHooksManager = require('./git-hooks-manager');
+const installer = require('./installer');
+
+module.exports = {
+  directoryDiscovery,
+  manifestManager,
+  driftDetector,
+  venvManager,
+  configManager,
+  gitHooksManager,
+  installer,
+};

package/lib/installer.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const configManager = require('./config-manager');
+const venvManager = require('./venv-manager');
+const gitHooksManager = require('./git-hooks-manager');
+
+async function init(projectRoot, options = {}) {
+  const results = { steps: [], errors: [] };
+
+  // Step 1: Detect project type
+  const projectType = await configManager.detectProjectType(projectRoot);
+  results.projectType = projectType;
+  results.steps.push(`Detected project type: ${projectType}`);
+
+  const enableFrontend = options.frontend !== false && (projectType === 'monorepo' || projectType === 'frontend');
+  const enableBackend = options.backend !== false && (projectType === 'monorepo' || projectType === 'backend');
+
+  // Step 2: Create config file
+  const configResult = await configManager.initConfig(projectRoot, {
+    force: options.force,
+    frontendDir: options.frontendDir,
+    backendDir: options.backendDir,
+  });
+  results.steps.push(configResult.created ? 'Created gimme-the-lint.config.js' : 'Config already exists');
+
+  // Step 3: Copy ESLint template (frontend)
+  if (enableFrontend) {
+    const frontendDir = path.join(projectRoot, options.frontendDir || 'frontend');
+    const eslintDest = path.join(frontendDir, 'eslint.config.js');
+
+    if (!await fs.pathExists(eslintDest) || options.force) {
+      try {
+        await configManager.copyTemplate('eslint.config.template.js', eslintDest, {
+          REACT_VERSION: options.reactVersion || '18.3',
+        });
+        results.steps.push('Created eslint.config.js template');
+      } catch (e) {
+        results.errors.push(`ESLint template: ${e.message}`);
+      }
+    }
+  }
+
+  // Step 4: Copy pyproject.toml template (backend)
+  if (enableBackend) {
+    const pyprojectDest = path.join(projectRoot, 'pyproject.toml');
+    if (!await fs.pathExists(pyprojectDest) || options.force) {
+      try {
+        await configManager.copyTemplate('pyproject.template.toml', pyprojectDest, {
+          PROJECT_NAME: path.basename(projectRoot),
+        });
+        results.steps.push('Created pyproject.toml with Ruff config');
+      } catch (e) {
+        results.errors.push(`pyproject.toml template: ${e.message}`);
+      }
+    }
+  }
+
+  // Step 5: Copy gitleaks template
+  const gitleaksDest = path.join(projectRoot, '.gitleaks.toml');
+  if (!await fs.pathExists(gitleaksDest) || options.force) {
+    try {
+      await configManager.copyTemplate('.gitleaks.template.toml', gitleaksDest);
+      results.steps.push('Created .gitleaks.toml');
+    } catch (e) {
+      results.errors.push(`gitleaks template: ${e.message}`);
+    }
+  }
+
+  // Step 6: Copy pre-commit config
+  const precommitDest = path.join(projectRoot, '.pre-commit-config.yaml');
+  if (!await fs.pathExists(precommitDest) || options.force) {
+    try {
+      await configManager.copyTemplate('.pre-commit-config.template.yaml', precommitDest);
+      results.steps.push('Created .pre-commit-config.yaml');
+    } catch (e) {
+      results.errors.push(`pre-commit template: ${e.message}`);
+    }
+  }
+
+  // Step 7: Copy commitlint config
+  const commitlintDest = path.join(projectRoot, 'commitlint.config.js');
+  if (!await fs.pathExists(commitlintDest) || options.force) {
+    try {
+      await configManager.copyTemplate('commitlint.config.template.js', commitlintDest);
+      results.steps.push('Created commitlint.config.js');
+    } catch (e) {
+      results.errors.push(`commitlint template: ${e.message}`);
+    }
+  }
+
+  // Step 8: Setup Python venv (backend)
+  if (enableBackend && options.setupVenv !== false) {
+    try {
+      const { pythonVersion } = venvManager.createVenv(projectRoot);
+      results.steps.push(`Created Python venv (${pythonVersion})`);
+
+      const reqFile = path.join(__dirname, '..', 'templates', 'requirements.linting.txt');
+      venvManager.installDeps(projectRoot, reqFile);
+      results.steps.push('Installed linting dependencies (ruff, mypy)');
+    } catch (e) {
+      results.errors.push(`Python venv: ${e.message}`);
+    }
+  }
+
+  return results;
+}
+
+module.exports = { init };

package/lib/manifest-manager.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const fs = require('fs-extra');
+const crypto = require('crypto');
+const path = require('path');
+
+async function hashFile(filePath) {
+  if (!await fs.pathExists(filePath)) {
+    return 'unknown';
+  }
+  const content = await fs.readFile(filePath, 'utf8');
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+function calculateAge(createdAt) {
+  const created = new Date(createdAt);
+  const now = new Date();
+  return Math.floor((now - created) / (1000 * 60 * 60 * 24));
+}
+
+async function createManifest({ tool, version, directories, violations, configPath, testExcluded }) {
+  const configHash = await hashFile(configPath);
+
+  return {
+    created_at: new Date().toISOString(),
+    tool,
+    version,
+    directories_baselined: directories,
+    total_directories: directories.length,
+    total_violations: violations,
+    config_hash: configHash,
+    test_excluded: testExcluded || [],
+  };
+}
+
+async function readManifest(manifestPath) {
+  if (!await fs.pathExists(manifestPath)) {
+    return null;
+  }
+  try {
+    return await fs.readJson(manifestPath);
+  } catch {
+    return null;
+  }
+}
+
+async function writeManifest(manifestPath, manifest) {
+  await fs.ensureDir(path.dirname(manifestPath));
+  await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+}
+
+module.exports = {
+  hashFile,
+  calculateAge,
+  createManifest,
+  readManifest,
+  writeManifest,
+};

package/lib/venv-manager.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+function getPythonCmd() {
+  for (const cmd of ['python3', 'python']) {
+    try {
+      const version = execSync(`${cmd} --version`, { encoding: 'utf8' }).trim();
+      const match = version.match(/(\d+)\.(\d+)/);
+      if (match && parseInt(match[1]) >= 3 && parseInt(match[2]) >= 8) {
+        return { cmd, version };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function getVenvPath(projectRoot) {
+  return path.join(projectRoot, '.venv');
+}
+
+function isVenvActive(projectRoot) {
+  const venvPath = getVenvPath(projectRoot);
+  const activatePath = path.join(venvPath, 'bin', 'activate');
+  return fs.existsSync(activatePath);
+}
+
+function createVenv(projectRoot) {
+  const python = getPythonCmd();
+  if (!python) {
+    throw new Error('Python 3.8+ not found. Please install Python 3.8 or later.');
+  }
+
+  const venvPath = getVenvPath(projectRoot);
+
+  if (!fs.existsSync(venvPath)) {
+    execSync(`${python.cmd} -m venv "${venvPath}"`, { cwd: projectRoot, stdio: 'inherit' });
+  }
+
+  return { venvPath, pythonVersion: python.version };
+}
+
+function installDeps(projectRoot, depsFile) {
+  const venvPath = getVenvPath(projectRoot);
+  const pip = path.join(venvPath, 'bin', 'pip');
+
+  execSync(`"${pip}" install --quiet --upgrade pip`, { cwd: projectRoot, stdio: 'inherit' });
+
+  if (depsFile && fs.existsSync(depsFile)) {
+    execSync(`"${pip}" install --quiet -r "${depsFile}"`, { cwd: projectRoot, stdio: 'inherit' });
+  }
+}
+
+function runInVenv(projectRoot, command) {
+  const venvPath = getVenvPath(projectRoot);
+  const activate = path.join(venvPath, 'bin', 'activate');
+  return execSync(`source "${activate}" && ${command}`, {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    shell: '/bin/bash',
+  });
+}
+
+function getStatus(projectRoot) {
+  const venvPath = getVenvPath(projectRoot);
+  const exists = fs.existsSync(venvPath);
+  let ruffVersion = null;
+  let pythonVersion = null;
+
+  if (exists) {
+    try {
+      ruffVersion = runInVenv(projectRoot, 'ruff --version').trim();
+    } catch { /* not installed */ }
+    try {
+      pythonVersion = runInVenv(projectRoot, 'python --version').trim();
+    } catch { /* not available */ }
+  }
+
+  return { exists, path: venvPath, ruffVersion, pythonVersion };
+}
+
+module.exports = {
+  getPythonCmd,
+  getVenvPath,
+  isVenvActive,
+  createVenv,
+  installDeps,
+  runInVenv,
+  getStatus,
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@theglitchking/gimme-the-lint",
+  "version": "1.0.0",
+  "description": "Progressive linting system with directory-chunked baselines, drift detection, and auto-healing for monorepo projects (Python + JS/TS)",
+  "keywords": [
+    "linting",
+    "progressive-linting",
+    "eslint",
+    "ruff",
+    "python",
+    "javascript",
+    "typescript",
+    "monorepo",
+    "git-hooks",
+    "baseline",
+    "drift-detection",
+    "claude-plugin"
+  ],
+  "author": {
+    "name": "TheGlitchKing",
+    "email": "theglitchking@users.noreply.github.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheGlitchKing/gimme-the-lint.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TheGlitchKing/gimme-the-lint/issues"
+  },
+  "homepage": "https://github.com/TheGlitchKing/gimme-the-lint",
+  "main": "lib/index.js",
+  "bin": {
+    "gimme-the-lint": "./bin/gimme-the-lint.js"
+  },
+  "scripts": {
+    "postinstall": "node ./bin/postinstall.js",
+    "setup:venv": "bash ./scripts/setup-venv.sh",
+    "install:hooks": "bash ./githooks/install.sh",
+    "lint:init": "node ./bin/gimme-the-lint.js init",
+    "check": "node ./bin/gimme-the-lint.js check",
+    "check:fix": "node ./bin/gimme-the-lint.js check --fix",
+    "baseline": "node ./bin/gimme-the-lint.js baseline",
+    "dashboard": "node ./bin/gimme-the-lint.js dashboard",
+    "prepublishOnly": "bash ./scripts/validate-version.sh",
+    "test": "node --test tests/*.test.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "templates/",
+    "githooks/",
+    "lib/",
+    ".claude-plugin/",
+    "agents/",
+    "docs/",
+    "install.sh",
+    "uninstall.sh",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  }
+}