commit-cop 1.0.0 → 1.1.0

package/src/fix/debugCode.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isCodeFile } from "../checks/utils.js";
+import { getStagedFiles } from "../git.js";
+import type { WipFixOptions } from "../types.js";
+
+const CONSOLE_LOG_LINE = /^\s*console\.log\([^)]*\);?\s*$/;
+const DEBUGGER_LINE = /^\s*debugger;?\s*$/;
+
+function stripDebugLines(
+  content: string,
+  options: { removeConsoleLog: boolean; removeDebugger: boolean }
+): { updated: string; removed: number } {
+  const lines = content.split("\n");
+  const kept: string[] = [];
+  let removed = 0;
+
+  for (const line of lines) {
+    const isConsoleLog = CONSOLE_LOG_LINE.test(line);
+    const isDebugger = DEBUGGER_LINE.test(line);
+
+    if (
+      (options.removeConsoleLog && isConsoleLog) ||
+      (options.removeDebugger && isDebugger)
+    ) {
+      removed += 1;
+      continue;
+    }
+    kept.push(line);
+  }
+
+  return { updated: kept.join("\n"), removed };
+}
+
+export function fixDebugCode(
+  cwd = process.cwd(),
+  options: WipFixOptions = {}
+): string[] {
+  const removeConsoleLog = Boolean(options.fixConsoleLog);
+  const removeDebugger = true;
+
+  if (!removeConsoleLog && !removeDebugger) {
+    return [];
+  }
+
+  let stagedFiles: string[];
+
+  try {
+    stagedFiles = getStagedFiles();
+  } catch {
+    return [];
+  }
+
+  const fixed: string[] = [];
+
+  for (const file of stagedFiles) {
+    if (!isCodeFile(file)) continue;
+
+    const absolutePath = path.resolve(cwd, file);
+    if (!fs.existsSync(absolutePath)) continue;
+
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    const { updated, removed } = stripDebugLines(content, {
+      removeConsoleLog,
+      removeDebugger,
+    });
+    if (removed === 0) continue;
+
+    fs.writeFileSync(absolutePath, updated, "utf-8");
+    fixed.push(file);
+  }
+
+  return fixed;
+}

package/src/fix/focusedTests.ts

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import path from "node:path";
+import { walkCodeFiles } from "./utils.js";
+
+const FOCUSED_TEST_PATTERN = /\b(test|it|describe)\.only\b/g;
+
+function isTestFile(filePath: string): boolean {
+  return filePath.includes("test") || filePath.includes("spec");
+}
+
+export function fixFocusedTests(cwd = process.cwd()): string[] {
+  const files = walkCodeFiles(cwd, isTestFile);
+  const fixed: string[] = [];
+
+  for (const absolutePath of files) {
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    if (!FOCUSED_TEST_PATTERN.test(content)) continue;
+
+    FOCUSED_TEST_PATTERN.lastIndex = 0;
+    const updated = content.replace(FOCUSED_TEST_PATTERN, "$1");
+    fs.writeFileSync(absolutePath, updated, "utf-8");
+    fixed.push(path.relative(cwd, absolutePath));
+  }
+
+  return fixed;
+}

package/src/fix/gitignore.ts

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const GITIGNORE_PATH = ".gitignore";
+
+type GitignoreEntry = {
+  line: string;
+  isPresent: (lines: string[]) => boolean;
+};
+
+const entries: GitignoreEntry[] = [
+  {
+    line: ".env",
+    isPresent: (lines) =>
+      lines.some((line) => line === ".env" || line.startsWith(".env")),
+  },
+  {
+    line: "node_modules/",
+    isPresent: (lines) =>
+      lines.some(
+        (line) => line === "node_modules" || line === "node_modules/"
+      ),
+  },
+  {
+    line: "dist/",
+    isPresent: (lines) =>
+      lines.some((line) => line === "dist" || line === "dist/"),
+  },
+  {
+    line: "build/",
+    isPresent: (lines) =>
+      lines.some((line) => line === "build" || line === "build/"),
+  },
+  {
+    line: ".next/",
+    isPresent: (lines) =>
+      lines.some((line) => line === ".next" || line === ".next/"),
+  },
+  {
+    line: "coverage/",
+    isPresent: (lines) =>
+      lines.some((line) => line === "coverage" || line === "coverage/"),
+  },
+  {
+    line: ".DS_Store",
+    isPresent: (lines) =>
+      lines.some((line) => line.toLowerCase() === ".ds_store"),
+  },
+  {
+    line: "Thumbs.db",
+    isPresent: (lines) =>
+      lines.some((line) => line.toLowerCase() === "thumbs.db"),
+  },
+  {
+    line: "desktop.ini",
+    isPresent: (lines) =>
+      lines.some((line) => line.toLowerCase() === "desktop.ini"),
+  },
+  {
+    line: "*.swp",
+    isPresent: (lines) => lines.includes("*.swp"),
+  },
+  {
+    line: "*.bak",
+    isPresent: (lines) => lines.includes("*.bak"),
+  },
+  {
+    line: "*.tmp",
+    isPresent: (lines) => lines.includes("*.tmp"),
+  },
+];
+
+function parseGitignoreLines(content: string): string[] {
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+
+export function fixGitignore(cwd = process.cwd()): string[] {
+  const filePath = path.join(cwd, GITIGNORE_PATH);
+  const applied: string[] = [];
+
+  const existingContent = fs.existsSync(filePath)
+    ? fs.readFileSync(filePath, "utf-8")
+    : "";
+  const existingLines = parseGitignoreLines(existingContent);
+
+  const missing = entries.filter((entry) => !entry.isPresent(existingLines));
+  if (missing.length === 0) {
+    return applied;
+  }
+
+  const additions = missing.map((entry) => entry.line);
+  const needsLeadingNewline =
+    existingContent.length > 0 && !existingContent.endsWith("\n");
+  const block =
+    (needsLeadingNewline ? "\n" : "") +
+    (existingContent.length > 0 ? "\n" : "") +
+    "# Added by commit-cop wip-fix\n" +
+    additions.join("\n") +
+    "\n";
+
+  fs.writeFileSync(filePath, existingContent + block, "utf-8");
+  applied.push(...additions);
+
+  return applied;
+}

package/src/fix/junkFiles.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import { isJunkFile } from "./matchers.js";
+import { walkRepo } from "./utils.js";
+
+export function fixJunkFiles(cwd = process.cwd()): string[] {
+  const removed: string[] = [];
+
+  walkRepo(cwd, (absolutePath, relativePath) => {
+    if (!isJunkFile(relativePath)) return;
+
+    fs.unlinkSync(absolutePath);
+    removed.push(relativePath);
+  });
+
+  return removed;
+}

package/src/fix/lockfile.ts

@@ -0,0 +1,23 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+export function fixLockfile(cwd = process.cwd()): boolean {
+  const packageJson = path.join(cwd, "package.json");
+  const packageLock = path.join(cwd, "package-lock.json");
+
+  if (!fs.existsSync(packageJson)) {
+    return false;
+  }
+
+  const needsInstall =
+    !fs.existsSync(packageLock) ||
+    fs.statSync(packageJson).mtimeMs > fs.statSync(packageLock).mtimeMs;
+
+  if (!needsInstall) {
+    return false;
+  }
+
+  execSync("npm install", { cwd, stdio: "inherit" });
+  return true;
+}

package/src/fix/matchers.ts

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import {
+  getBaseName,
+  matchesAnyPattern,
+  normalizePath,
+} from "../checks/utils.js";
+
+export const GENERATED_FOLDERS = [
+  "node_modules/",
+  "dist/",
+  "build/",
+  ".next/",
+  "coverage/",
+];
+
+const junkExactNames = new Set([
+  ".ds_store",
+  "thumbs.db",
+  "desktop.ini",
+]);
+
+const junkNamePatterns = [/\.swp$/i, /\.bak$/i, /\.tmp$/i, /~$/];
+
+const sensitiveExactNames = new Set([
+  "id_rsa",
+  "id_ed25519",
+  "credentials.json",
+  "serviceaccountkey.json",
+  ".npmrc",
+  ".pypirc",
+]);
+
+const sensitiveNamePatterns = [
+  /\.pem$/i,
+  /\.p12$/i,
+  /\.key$/i,
+  /^firebase-adminsdk.*\.json$/i,
+];
+
+const binaryExtensions = new Set([
+  ".zip",
+  ".exe",
+  ".dll",
+  ".mp4",
+  ".mov",
+  ".sqlite",
+  ".db",
+]);
+
+const MAX_SIZE_MB = 5;
+
+function matchesGeneratedFolder(normalizedPath: string): string | null {
+  for (const folder of GENERATED_FOLDERS) {
+    if (
+      normalizedPath.startsWith(folder) ||
+      normalizedPath.includes(`/${folder}`)
+    ) {
+      return folder;
+    }
+  }
+  return null;
+}
+
+export function isEnvFile(file: string): boolean {
+  const baseName = getBaseName(file);
+  return baseName === ".env" || baseName.startsWith(".env.");
+}
+
+export function isSensitiveFile(file: string): boolean {
+  const baseName = getBaseName(file);
+  const normalizedBaseName = baseName.toLowerCase();
+  const normalizedPath = normalizePath(file).toLowerCase();
+
+  return (
+    sensitiveExactNames.has(normalizedBaseName) ||
+    matchesAnyPattern(baseName, sensitiveNamePatterns) ||
+    normalizedPath.endsWith("/credentials.json") ||
+    normalizedPath.includes("serviceaccountkey.json")
+  );
+}
+
+export function isGeneratedPath(file: string): boolean {
+  return matchesGeneratedFolder(normalizePath(file)) !== null;
+}
+
+export function isJunkFile(file: string): boolean {
+  const baseName = getBaseName(file);
+  const normalizedBaseName = baseName.toLowerCase();
+
+  return (
+    junkExactNames.has(normalizedBaseName) ||
+    matchesAnyPattern(baseName, junkNamePatterns)
+  );
+}
+
+function hasNullBytes(file: string): boolean {
+  const buffer = fs.readFileSync(file);
+  const sampleSize = Math.min(buffer.length, 8192);
+
+  for (let index = 0; index < sampleSize; index += 1) {
+    if (buffer[index] === 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function isBinaryFile(file: string): boolean {
+  if (!fs.existsSync(file)) return false;
+
+  const baseName = getBaseName(file);
+  const extension = baseName.includes(".")
+    ? baseName.slice(baseName.lastIndexOf(".")).toLowerCase()
+    : "";
+
+  if (binaryExtensions.has(extension)) return true;
+
+  try {
+    return hasNullBytes(file);
+  } catch {
+    return false;
+  }
+}
+
+export function isLargeFile(file: string): boolean {
+  if (!fs.existsSync(file)) return false;
+
+  const sizeMb = fs.statSync(file).size / 1024 / 1024;
+  return sizeMb > MAX_SIZE_MB;
+}
+
+export function shouldUnstage(file: string): string | null {
+  if (isEnvFile(file)) return "environment file";
+  if (isSensitiveFile(file)) return "sensitive file";
+  if (isGeneratedPath(file)) return "generated path";
+  if (isJunkFile(file)) return "junk file";
+  if (isBinaryFile(file)) return "binary file";
+  if (isLargeFile(file)) return "large file";
+  return null;
+}

package/src/fix/runFix.ts

@@ -0,0 +1,96 @@
+import chalk from "chalk";
+import type { WipFixOptions } from "../types.js";
+import { fixDebugCode } from "./debugCode.js";
+import { fixFocusedTests } from "./focusedTests.js";
+import { fixGitignore } from "./gitignore.js";
+import { fixJunkFiles } from "./junkFiles.js";
+import { fixLockfile } from "./lockfile.js";
+import { fixUnstageRiskyFiles } from "./unstage.js";
+
+function printSection(title: string, items: string[]): void {
+  if (items.length === 0) return;
+  console.log(chalk.green(`\n${title}`));
+  for (const item of items) {
+    console.log(`  ${item}`);
+  }
+}
+
+function printSkipped(message: string): void {
+  console.log(chalk.dim(`\n${message}`));
+}
+
+export function runWipFix(options: WipFixOptions = {}): void {
+  const fixConsoleLog = Boolean(options.fixConsoleLog);
+
+  console.log(chalk.bold("commit-cop wip-fix"));
+  console.log(chalk.dim("(work in progress — more fixes may be added later)\n"));
+
+  const gitignoreAdded = fixGitignore();
+  const testsFixed = fixFocusedTests();
+  const debugFixed = fixDebugCode(process.cwd(), { fixConsoleLog });
+  const junkRemoved = fixJunkFiles();
+  const unstaged = fixUnstageRiskyFiles();
+  const lockfileSynced = fixLockfile();
+
+  if (gitignoreAdded.length > 0) {
+    console.log(chalk.green("Updated .gitignore:"));
+    for (const entry of gitignoreAdded) {
+      console.log(`  + ${entry}`);
+    }
+  } else {
+    console.log(
+      chalk.dim(".gitignore already includes expected entries from checks")
+    );
+  }
+
+  printSection("Replaced focused test (.only) calls in:", testsFixed);
+  if (testsFixed.length === 0) {
+    printSkipped("No test.only / it.only / describe.only in test files");
+  }
+
+  if (fixConsoleLog) {
+    printSection("Removed debug lines from staged files:", debugFixed);
+    if (debugFixed.length === 0) {
+      printSkipped("No staged standalone console.log or debugger lines");
+    }
+  } else {
+    printSkipped("Skipped console.log removal (use --fix-console-log to enable)");
+    if (debugFixed.length > 0) {
+      printSection("Removed debugger lines from staged files:", debugFixed);
+    } else {
+      printSkipped("No staged debugger lines");
+    }
+  }
+
+  printSection("Deleted junk files:", junkRemoved);
+  if (junkRemoved.length === 0) {
+    printSkipped("No junk files found on disk");
+  }
+
+  printSection("Unstaged risky files:", unstaged);
+  if (unstaged.length === 0) {
+    printSkipped("No staged env, sensitive, generated, junk, binary, or large files");
+  }
+
+  if (lockfileSynced) {
+    console.log(chalk.green("\nRan npm install to sync package-lock.json"));
+  } else {
+    printSkipped("package-lock.json is up to date (or no package.json)");
+  }
+
+  printSkipped(
+    "Cannot auto-fix: merge conflicts, secrets, or localhost URLs — resolve those manually"
+  );
+
+  const changed =
+    gitignoreAdded.length > 0 ||
+    testsFixed.length > 0 ||
+    debugFixed.length > 0 ||
+    junkRemoved.length > 0 ||
+    unstaged.length > 0 ||
+    lockfileSynced;
+
+  if (!changed) {
+    console.log(chalk.dim("\nNothing to fix."));
+  }
+}

package/src/fix/unstage.ts

@@ -0,0 +1,25 @@
+import { execSync } from "node:child_process";
+import { getStagedFiles } from "../git.js";
+import { shouldUnstage } from "./matchers.js";
+
+export function fixUnstageRiskyFiles(): string[] {
+  let stagedFiles: string[];
+
+  try {
+    stagedFiles = getStagedFiles();
+  } catch {
+    return [];
+  }
+
+  const unstaged: string[] = [];
+
+  for (const file of stagedFiles) {
+    const reason = shouldUnstage(file);
+    if (!reason) continue;
+
+    execSync(`git restore --staged -- "${file}"`, { stdio: "pipe" });
+    unstaged.push(`${file} (${reason})`);
+  }
+
+  return unstaged;
+}

package/src/fix/utils.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const SKIP_DIRS = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".git",
+]);
+
+export function walkRepo(
+  cwd: string,
+  onFile: (absolutePath: string, relativePath: string) => void
+): void {
+  function walk(dir: string): void {
+    if (!fs.existsSync(dir)) return;
+
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+
+      const absolutePath = path.join(dir, entry.name);
+      const relativePath = path.relative(cwd, absolutePath);
+
+      if (entry.isDirectory()) {
+        walk(absolutePath);
+        continue;
+      }
+
+      onFile(absolutePath, relativePath);
+    }
+  }
+
+  walk(cwd);
+}
+
+export function walkCodeFiles(
+  cwd: string,
+  predicate: (relativePath: string) => boolean,
+  files: string[] = []
+): string[] {
+  walkRepo(cwd, (absolutePath, relativePath) => {
+    if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(relativePath)) return;
+    if (!predicate(relativePath)) return;
+    files.push(absolutePath);
+  });
+
+  return files;
+}

package/src/git.ts

@@ -1,4 +1,5 @@
 import { execSync } from "node:child_process";
+import { PRODUCT_NAME } from "./brand.js";
 
 export function getStagedFiles(): string[] {
   try {
@@ -11,6 +12,6 @@ export function getStagedFiles(): string[] {
       .map((file) => file.trim())
       .filter(Boolean);
   } catch {
-    throw new Error("CommitClean must be run inside a Git repository.");
+    throw new Error(`${PRODUCT_NAME} must be run inside a Git repository.`);
   }
 }

package/src/hook.ts

@@ -0,0 +1,98 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { CLI_NAME, PRODUCT_NAME } from "./brand.js";
+
+const HOOK_MARKER = "# Generated by Commit Cop";
+const BACKUP_SUFFIX = ".commit-cop.backup";
+
+function getGitHooksDir(): string {
+  try {
+    const gitPath = execSync("git rev-parse --git-path hooks", {
+      encoding: "utf-8",
+    }).trim();
+
+    return path.resolve(gitPath);
+  } catch {
+    throw new Error(`${PRODUCT_NAME} install must be run inside a Git repository.`);
+  }
+}
+
+function buildHookScript(strict: boolean): string {
+  const strictFlag = strict ? " --strict" : "";
+
+  return `#!/bin/sh
+${HOOK_MARKER}
+# Re-run: npx ${CLI_NAME} install
+
+cd "$(git rev-parse --show-toplevel)" || exit 1
+
+if [ -x "./node_modules/.bin/${CLI_NAME}" ]; then
+  exec ./node_modules/.bin/${CLI_NAME}${strictFlag}
+fi
+
+if command -v ${CLI_NAME} >/dev/null 2>&1; then
+  exec ${CLI_NAME}${strictFlag}
+fi
+
+exec npx ${CLI_NAME}${strictFlag}
+`;
+}
+
+export function installHook(strict = false): void {
+  const hooksDir = getGitHooksDir();
+  const hookPath = path.join(hooksDir, "pre-commit");
+  const backupPath = `${hookPath}${BACKUP_SUFFIX}`;
+
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  if (fs.existsSync(hookPath)) {
+    const existing = fs.readFileSync(hookPath, "utf-8");
+
+    if (existing.includes(HOOK_MARKER)) {
+      console.log(`${PRODUCT_NAME}: Updating existing pre-commit hook.`);
+    } else {
+      fs.copyFileSync(hookPath, backupPath);
+      console.log(
+        `${PRODUCT_NAME}: Backed up existing pre-commit hook to ${path.basename(backupPath)}.`
+      );
+    }
+  }
+
+  fs.writeFileSync(hookPath, buildHookScript(strict), { mode: 0o755 });
+
+  console.log(`${PRODUCT_NAME}: Pre-commit hook installed.`);
+  console.log(`  ${hookPath}`);
+  console.log("");
+  console.log("Commit Cop will now run automatically on git commit.");
+}
+
+export function uninstallHook(): void {
+  const hooksDir = getGitHooksDir();
+  const hookPath = path.join(hooksDir, "pre-commit");
+  const backupPath = `${hookPath}${BACKUP_SUFFIX}`;
+
+  if (!fs.existsSync(hookPath)) {
+    console.log(`${PRODUCT_NAME}: No pre-commit hook found.`);
+    return;
+  }
+
+  const existing = fs.readFileSync(hookPath, "utf-8");
+
+  if (!existing.includes(HOOK_MARKER)) {
+    throw new Error(
+      `${PRODUCT_NAME} did not install this pre-commit hook. Remove it manually if needed.`
+    );
+  }
+
+  fs.unlinkSync(hookPath);
+
+  if (fs.existsSync(backupPath)) {
+    fs.copyFileSync(backupPath, hookPath);
+    fs.unlinkSync(backupPath);
+    console.log(`${PRODUCT_NAME}: Pre-commit hook removed and previous hook restored.`);
+    return;
+  }
+
+  console.log(`${PRODUCT_NAME}: Pre-commit hook removed.`);
+}