@re3se/gitsniffer 1.0.0

package/README.md

@@ -0,0 +1,67 @@
+# GitSniffer
+### Smart Code Sentry for Your Terminal
+
+> "If it's not clean, it's not finished."
+
+GitSniffer is a CLI tool designed to act as an intelligent filter for your codebase. It ensures that no debug leftovers, private keys, or sloppy comments make their way into your repository. It's not just a linter, it's a gatekeeper for quality.
+
+## 🚀 The Philosophy
+I build ecosystems where quality is non-negotiable. GitSniffer was born from a simple need: **intentionality**.
+
+*   **Security First**: Prevent API key leaks before they happen.
+*   **Clean Code**: Stop `console.log` and `debugger` statements from polluting production.
+*   **Efficiency**: Catch errors in the staging area, seconds before the commit.
+
+## ⚙️ How It Works
+GitSniffer hooks into your workflow at the most critical moment: **pre-commit**.
+
+1.  **Scans**: It analyzes *only* your staged changes (`git diff --cached`).
+2.  **Sniffs**: Applies regex-based heuristics to detect code smells and security risks.
+3.  **Blocks**: If it finds a critical error (like a private key), it stops the commit.
+
+## 🔧 Installation
+Install it globally to use it across all your projects:
+
+```bash
+npm install -g gitsniffer
+```
+
+## 🚀 Usage
+Run it manually in any git repository:
+
+```bash
+gitsniffer --run
+```
+
+### Automate with Git Hooks
+To enforce quality standards automatically, add it to your pre-commit hook.
+
+**Option 1: Raw Git Hook**
+Add this to `.git/hooks/pre-commit` and make it executable (`chmod +x`):
+```bash
+#!/bin/sh
+gitsniffer --run
+```
+
+**Option 2: Husky**
+If you use Husky in your project:
+```bash
+npx husky add .husky/pre-commit "gitsniffer --run"
+```
+
+## 🛡️ Default Rules
+GitSniffer comes pre-configured with a zero-tolerance policy for:
+
+*   🔴 **Private Keys** (AWS, RSA, generic private keys) -> `[ERROR]` (Blocks commit)
+*   🔴 **Debugger Statements** -> `[ERROR]` (Blocks commit)
+*   🟡 **Console Logs** -> `[WARNING]`
+*   🔵 **TODO Comments** -> `[INFO]`
+
+## 🛠️ Tech Stack
+Built with intentionality using:
+*   **Node.js**
+*   **Commander.js**
+*   **Execa**
+*   **Chalk**
+
+---

package/bin/gitsniffer.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js';

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@re3se/gitsniffer",
+  "version": "1.0.0",
+  "description": "An intelligent CLI tool that prevents bad code and security leaks from entering your repository.",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "gitsniffer": "./bin/gitsniffer.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "git",
+    "cli",
+    "linter",
+    "security",
+    "clean-code",
+    "pre-commit"
+  ],
+  "author": "re3se",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "execa": "^8.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/config.js

@@ -0,0 +1,32 @@
+export const defaultRules = [
+  {
+    id: 'no-console',
+    message: 'Found console.log usage',
+    regex: /^(?!\s*\/\/).*console\.log\(/,
+    severity: 'warning'
+  },
+  {
+    id: 'no-todo',
+    message: 'Found TODO comment',
+    regex: /\/\/\s*TODO:/i,
+    severity: 'info'
+  },
+  {
+    id: 'no-private-keys',
+    message: 'Potential private key found',
+    regex: /-----BEGIN PRIVATE KEY-----/,
+    severity: 'error'
+  },
+  {
+    id: 'no-aws-keys',
+    message: 'Potential AWS Access Key found',
+    regex: /(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}/,
+    severity: 'error'
+  },
+  {
+    id: 'no-debugger',
+    message: 'Found debugger statement',
+    regex: /debugger;?/,
+    severity: 'error'
+  }
+];

package/src/git.js

@@ -0,0 +1,69 @@
+import { execa } from 'execa';
+import { extname } from 'path';
+
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico',
+  '.pdf', '.zip', '.tar', '.gz', '.7z',
+  '.exe', '.dll', '.so', '.dylib', '.bin',
+  '.mp3', '.mp4', '.mov', '.avi', '.woff', '.woff2', '.ttf', '.eot'
+]);
+
+export async function getGitDiff() {
+  try {
+    const { stdout: stagedFiles } = await execa('git', ['diff', '--name-only', '--cached']);
+    
+    const { stdout: diffOutput } = await execa('git', ['diff', '--cached', '--unified=0']);
+    
+    return parseDiff(diffOutput);
+  } catch (error) {
+    console.error('Error executing git command:', error.message);
+    return [];
+  }
+}
+
+function parseDiff(diffOutput) {
+  const files = [];
+  let currentFile = null;
+
+  const lines = diffOutput.split('\n');
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git')) {
+      const match = line.match(/b\/(.*)$/);
+      if (match) {
+        const filePath = match[1];
+        
+        if (isBinaryFile(filePath)) {
+          currentFile = null;
+          continue;
+        }
+
+        currentFile = {
+          path: filePath,
+          changes: []
+        };
+        files.push(currentFile);
+      }
+    } else if (line.startsWith('@@')) {
+      const match = line.match(/\+(\d+)(?:,(\d+))?/);
+      if (match && currentFile) {
+        currentFile.currentLineNumber = parseInt(match[1], 10);
+      }
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      if (currentFile && currentFile.currentLineNumber !== undefined) {
+        currentFile.changes.push({
+          line: currentFile.currentLineNumber,
+          content: line.substring(1)
+        });
+        currentFile.currentLineNumber++;
+      }
+    }
+  }
+
+  return files;
+}
+
+function isBinaryFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}

package/src/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getGitDiff } from './git.js';
+import { scanCode } from './scanner.js';
+import { reportIssues } from './reporter.js';
+import { defaultRules } from './config.js';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+  .name('gitsniffer')
+  .description('Smart CLI tool to prevent committing bad code')
+  .version(packageJson.version);
+
+program
+  .option('-r, --run', 'Run the sniffer on staged files')
+  .action(async (options) => {
+    if (options.run) {
+      console.log(chalk.cyan('Starting code analysis...'));
+      
+      const files = await getGitDiff();
+      
+      if (files.length === 0) {
+        console.log(chalk.green('No staged changes detected.'));
+        return;
+      }
+
+      const issues = scanCode(files, defaultRules);
+      const exitCode = reportIssues(issues);
+      
+      process.exit(exitCode);
+    } else {
+      program.help();
+    }
+  });
+
+program.parse(process.argv);

package/src/reporter.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+
+export function reportIssues(issues) {
+  if (issues.length === 0) {
+    console.log(chalk.green('No issues found.'));
+    return 0;
+  }
+
+  console.log(chalk.bold.underline(`Found ${issues.length} potential issues:\n`));
+
+  let errorCount = 0;
+  let warningCount = 0;
+
+  issues.forEach(issue => {
+    const location = chalk.gray(`${issue.file}:${issue.line}`);
+    let severityLabel;
+    let messageColor;
+
+    switch (issue.severity) {
+      case 'error':
+        severityLabel = chalk.red('[ERROR]');
+        messageColor = chalk.red;
+        errorCount++;
+        break;
+      case 'warning':
+        severityLabel = chalk.yellow('[WARNING]');
+        messageColor = chalk.yellow;
+        warningCount++;
+        break;
+      case 'info':
+        severityLabel = chalk.blue('[INFO]');
+        messageColor = chalk.blue;
+        break;
+      default:
+        severityLabel = chalk.white('[UNKNOWN]');
+        messageColor = chalk.white;
+    }
+
+    console.log(`  ${severityLabel} ${messageColor(issue.message)}`);
+    console.log(`     Location: ${location}`);
+    console.log(`     Code:     ${chalk.gray(issue.content)}`);
+    console.log('');
+  });
+
+  if (errorCount > 0) {
+    console.log(chalk.red.bold(`Analysis complete: ${errorCount} errors and ${warningCount} warnings found.`));
+    return 1;
+  } else {
+    console.log(chalk.yellow.bold(`Analysis complete: ${warningCount} warnings found.`));
+    return 0;
+  }
+}

package/src/scanner.js

@@ -0,0 +1,22 @@
+export function scanCode(files, rules) {
+  const issues = [];
+
+  for (const file of files) {
+    for (const change of file.changes) {
+      for (const rule of rules) {
+        if (rule.regex.test(change.content)) {
+          issues.push({
+            file: file.path,
+            line: change.line,
+            content: change.content.trim(),
+            ruleId: rule.id,
+            message: rule.message,
+            severity: rule.severity
+          });
+        }
+      }
+    }
+  }
+
+  return issues;
+}