Pre Commit

#!/usr/bin/env bun
/**
 * HookGenerator - Generate .pre-commit-config.yaml templates
 *
 * Usage:
 *   bun run HookGenerator.ts <preset> [options]
 *
 * Presets:
 *   minimal     - Basic hooks (whitespace, yaml, merge conflicts)
 *   python      - Python project hooks (black, isort, flake8, mypy)
 *   javascript  - JS/TS project hooks (prettier, eslint)
 *   terraform   - Infrastructure hooks (fmt, validate, docs, tflint)
 *   kubernetes  - K8s/Helm hooks (yamllint, kubeconform, checkov)
 *   security    - Security-focused hooks (gitleaks, bandit, trivy)
 *   full        - Comprehensive setup with all categories
 */

import { writeFileSync, existsSync } from "fs";
import { stringify as stringifyYaml } from "yaml";

interface HookConfig {
  id: string;
  name?: string;
  args?: string[];
  files?: string;
  exclude?: string;
  types?: string[];
  types_or?: string[];
  stages?: string[];
  additional_dependencies?: string[];
  always_run?: boolean;
  pass_filenames?: boolean;
}

interface RepoConfig {
  repo: string;
  rev: string;
  hooks: HookConfig[];
}

interface PreCommitConfig {
  default_stages?: string[];
  fail_fast?: boolean;
  repos: RepoConfig[];
}

// Hook templates by category
const hookTemplates: Record<string, RepoConfig[]> = {
  base: [
    {
      repo: "https://github.com/pre-commit/pre-commit-hooks",
      rev: "v5.0.0",
      hooks: [
        { id: "trailing-whitespace" },
        { id: "end-of-file-fixer" },
        { id: "check-yaml", args: ["--allow-multiple-documents"] },
        { id: "check-json" },
        { id: "check-added-large-files", args: ["--maxkb=1000"] },
        { id: "check-merge-conflict" },
        { id: "detect-private-key" },
        { id: "no-commit-to-branch", args: ["--branch", "main", "--branch", "master"] },
      ],
    },
  ],

  python: [
    {
      repo: "https://github.com/astral-sh/ruff-pre-commit",
      rev: "v0.7.3",
      hooks: [
        { id: "ruff", args: ["--fix"] },
        { id: "ruff-format" },
      ],
    },
    {
      repo: "https://github.com/pre-commit/mirrors-mypy",
      rev: "v1.13.0",
      hooks: [
        {
          id: "mypy",
          additional_dependencies: ["types-requests", "types-PyYAML"],
        },
      ],
    },
    {
      repo: "https://github.com/pycqa/bandit",
      rev: "1.7.10",
      hooks: [
        {
          id: "bandit",
          args: ["-c", "pyproject.toml"],
          additional_dependencies: ["bandit[toml]"],
        },
      ],
    },
  ],

  python_classic: [
    {
      repo: "https://github.com/psf/black",
      rev: "24.10.0",
      hooks: [{ id: "black" }],
    },
    {
      repo: "https://github.com/pycqa/isort",
      rev: "5.13.2",
      hooks: [{ id: "isort", args: ["--profile=black"] }],
    },
    {
      repo: "https://github.com/pycqa/flake8",
      rev: "7.1.1",
      hooks: [
        { id: "flake8", args: ["--max-line-length=88", "--extend-ignore=E203"] },
      ],
    },
  ],

  javascript: [
    {
      repo: "https://github.com/biomejs/pre-commit",
      rev: "v0.5.0",
      hooks: [
        {
          id: "biome-check",
          additional_dependencies: ["@biomejs/biome@1.9.4"],
        },
      ],
    },
  ],

  javascript_classic: [
    {
      repo: "https://github.com/pre-commit/mirrors-prettier",
      rev: "v4.0.0-alpha.8",
      hooks: [
        {
          id: "prettier",
          types_or: ["javascript", "jsx", "ts", "tsx", "json", "yaml", "markdown"],
        },
      ],
    },
    {
      repo: "https://github.com/pre-commit/mirrors-eslint",
      rev: "v9.14.0",
      hooks: [
        {
          id: "eslint",
          files: "\\.[jt]sx?$",
          additional_dependencies: [
            "eslint@9.14.0",
            "typescript",
            "@typescript-eslint/parser",
            "@typescript-eslint/eslint-plugin",
          ],
        },
      ],
    },
  ],

  terraform: [
    {
      repo: "https://github.com/antonbabenko/pre-commit-terraform",
      rev: "v1.96.2",
      hooks: [
        { id: "terraform_fmt" },
        { id: "terraform_validate" },
        {
          id: "terraform_docs",
          args: [
            "--hook-config=--path-to-file=README.md",
            "--hook-config=--create-file-if-not-exist=true",
          ],
        },
        {
          id: "terraform_tflint",
          args: ["--args=--config=__GIT_WORKING_DIR__/.tflint.hcl"],
        },
        {
          id: "terraform_trivy",
          args: ["--args=--severity=HIGH,CRITICAL"],
        },
      ],
    },
  ],

  kubernetes: [
    {
      repo: "https://github.com/adrienverge/yamllint",
      rev: "v1.35.1",
      hooks: [{ id: "yamllint", args: ["-c", ".yamllint.yaml"] }],
    },
    {
      repo: "https://github.com/gruntwork-io/pre-commit",
      rev: "v0.1.23",
      hooks: [{ id: "helmlint" }],
    },
    {
      repo: "https://github.com/bridgecrewio/checkov",
      rev: "3.2.277",
      hooks: [
        {
          id: "checkov",
          args: ["--framework", "kubernetes", "--quiet", "--compact"],
        },
      ],
    },
  ],

  security: [
    {
      repo: "https://github.com/gitleaks/gitleaks",
      rev: "v8.21.2",
      hooks: [{ id: "gitleaks" }],
    },
    {
      repo: "https://github.com/Yelp/detect-secrets",
      rev: "v1.5.0",
      hooks: [
        { id: "detect-secrets", args: ["--baseline", ".secrets.baseline"] },
      ],
    },
  ],

  yaml: [
    {
      repo: "https://github.com/adrienverge/yamllint",
      rev: "v1.35.1",
      hooks: [{ id: "yamllint", args: ["-c", ".yamllint.yaml"] }],
    },
  ],

  shell: [
    {
      repo: "https://github.com/shellcheck-py/shellcheck-py",
      rev: "v0.10.0.1",
      hooks: [{ id: "shellcheck", args: ["-x"] }],
    },
    {
      repo: "https://github.com/scop/pre-commit-shfmt",
      rev: "v3.10.0-1",
      hooks: [{ id: "shfmt", args: ["-i", "2", "-ci"] }],
    },
  ],

  go: [
    {
      repo: "https://github.com/golangci/golangci-lint",
      rev: "v1.62.0",
      hooks: [{ id: "golangci-lint" }],
    },
    {
      repo: "https://github.com/dnephin/pre-commit-golang",
      rev: "v0.5.1",
      hooks: [{ id: "go-fmt" }, { id: "go-vet" }, { id: "go-imports" }],
    },
  ],

  docker: [
    {
      repo: "https://github.com/hadolint/hadolint",
      rev: "v2.12.0",
      hooks: [{ id: "hadolint" }],
    },
  ],

  docs: [
    {
      repo: "https://github.com/igorshubovych/markdownlint-cli",
      rev: "v0.42.0",
      hooks: [{ id: "markdownlint", args: ["--fix"] }],
    },
    {
      repo: "https://github.com/crate-ci/typos",
      rev: "v1.27.0",
      hooks: [{ id: "typos" }],
    },
  ],

  commits: [
    {
      repo: "https://github.com/compilerla/conventional-pre-commit",
      rev: "v3.6.0",
      hooks: [
        {
          id: "conventional-pre-commit",
          stages: ["commit-msg"],
          args: ["feat", "fix", "docs", "style", "refactor", "perf", "test", "chore", "ci", "build"],
        },
      ],
    },
  ],
};

// Preset definitions
const presets: Record<string, string[]> = {
  minimal: ["base"],
  python: ["base", "python", "security"],
  python_classic: ["base", "python_classic", "security"],
  javascript: ["base", "javascript", "security"],
  javascript_classic: ["base", "javascript_classic", "security"],
  terraform: ["base", "terraform"],
  kubernetes: ["base", "kubernetes", "security"],
  infrastructure: ["base", "terraform", "kubernetes", "security"],
  security: ["base", "security"],
  go: ["base", "go", "security"],
  full: ["base", "yaml", "shell", "docker", "docs", "security", "commits"],
};

function generateConfig(categories: string[]): PreCommitConfig {
  const repos: RepoConfig[] = [];
  const seenRepos = new Set<string>();

  for (const category of categories) {
    const templates = hookTemplates[category];
    if (!templates) {
      console.warn(`⚠️  Unknown category: ${category}`);
      continue;
    }

    for (const template of templates) {
      // Avoid duplicate repos
      if (seenRepos.has(template.repo)) {
        // Merge hooks into existing repo
        const existingRepo = repos.find((r) => r.repo === template.repo);
        if (existingRepo) {
          for (const hook of template.hooks) {
            if (!existingRepo.hooks.some((h) => h.id === hook.id)) {
              existingRepo.hooks.push(hook);
            }
          }
        }
      } else {
        repos.push({ ...template, hooks: [...template.hooks] });
        seenRepos.add(template.repo);
      }
    }
  }

  return {
    default_stages: ["pre-commit"],
    fail_fast: false,
    repos,
  };
}

function generateYaml(config: PreCommitConfig): string {
  // Custom YAML generation for cleaner output
  let yaml = "# .pre-commit-config.yaml\n";
  yaml += "# Generated by HookGenerator\n\n";

  if (config.default_stages) {
    yaml += `default_stages: [${config.default_stages.join(", ")}]\n`;
  }
  if (config.fail_fast !== undefined) {
    yaml += `fail_fast: ${config.fail_fast}\n`;
  }

  yaml += "\nrepos:\n";

  for (const repo of config.repos) {
    yaml += `  - repo: ${repo.repo}\n`;
    yaml += `    rev: ${repo.rev}\n`;
    yaml += `    hooks:\n`;

    for (const hook of repo.hooks) {
      yaml += `      - id: ${hook.id}\n`;

      if (hook.name) {
        yaml += `        name: ${hook.name}\n`;
      }
      if (hook.args && hook.args.length > 0) {
        if (hook.args.length === 1) {
          yaml += `        args: [${hook.args[0]}]\n`;
        } else {
          yaml += `        args:\n`;
          for (const arg of hook.args) {
            yaml += `          - ${arg}\n`;
          }
        }
      }
      if (hook.files) {
        yaml += `        files: ${hook.files}\n`;
      }
      if (hook.exclude) {
        yaml += `        exclude: ${hook.exclude}\n`;
      }
      if (hook.types && hook.types.length > 0) {
        yaml += `        types: [${hook.types.join(", ")}]\n`;
      }
      if (hook.types_or && hook.types_or.length > 0) {
        yaml += `        types_or: [${hook.types_or.join(", ")}]\n`;
      }
      if (hook.stages && hook.stages.length > 0) {
        yaml += `        stages: [${hook.stages.join(", ")}]\n`;
      }
      if (hook.additional_dependencies && hook.additional_dependencies.length > 0) {
        yaml += `        additional_dependencies:\n`;
        for (const dep of hook.additional_dependencies) {
          yaml += `          - ${dep}\n`;
        }
      }
      if (hook.always_run) {
        yaml += `        always_run: true\n`;
      }
      if (hook.pass_filenames === false) {
        yaml += `        pass_filenames: false\n`;
      }
    }
    yaml += "\n";
  }

  return yaml.trim() + "\n";
}

function showHelp(): void {
  console.log(`
HookGenerator - Generate .pre-commit-config.yaml templates

Usage:
  bun run HookGenerator.ts <preset> [options]

Presets:
  minimal           Basic hooks (whitespace, yaml, merge conflicts)
  python            Python project (ruff, mypy, bandit)
  python_classic    Python project (black, isort, flake8)
  javascript        JS/TS project (biome)
  javascript_classic JS/TS project (prettier, eslint)
  terraform         Terraform/IaC hooks
  kubernetes        K8s/Helm hooks
  infrastructure    Terraform + Kubernetes
  security          Security-focused hooks
  go                Go project hooks
  full              Comprehensive setup

Options:
  --output, -o <file>  Output file (default: .pre-commit-config.yaml)
  --force, -f          Overwrite existing file
  --dry-run            Print config without writing
  --add <categories>   Add specific categories (comma-separated)
  --list               List available categories

Categories:
  base, python, python_classic, javascript, javascript_classic,
  terraform, kubernetes, security, yaml, shell, go, docker, docs, commits

Examples:
  bun run HookGenerator.ts python
  bun run HookGenerator.ts minimal --add security,commits
  bun run HookGenerator.ts terraform --dry-run
  bun run HookGenerator.ts --list
`);
}

function listCategories(): void {
  console.log("Available Categories:\n");

  for (const [category, repos] of Object.entries(hookTemplates)) {
    const hookCount = repos.reduce((acc, r) => acc + r.hooks.length, 0);
    console.log(`  ${category.padEnd(20)} ${hookCount} hooks`);
    for (const repo of repos) {
      const repoName = repo.repo.split("/").slice(-1)[0];
      console.log(`    └─ ${repoName}: ${repo.hooks.map((h) => h.id).join(", ")}`);
    }
  }

  console.log("\nPresets:\n");
  for (const [preset, categories] of Object.entries(presets)) {
    console.log(`  ${preset.padEnd(20)} ${categories.join(", ")}`);
  }
}

async function main(): Promise<void> {
  const args = process.argv.slice(2);

  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
    showHelp();
    process.exit(0);
  }

  if (args.includes("--list")) {
    listCategories();
    process.exit(0);
  }

  // Parse options
  const preset = args[0];
  const outputIndex = args.findIndex((a) => a === "--output" || a === "-o");
  const outputFile =
    outputIndex > -1 ? args[outputIndex + 1] : ".pre-commit-config.yaml";
  const force = args.includes("--force") || args.includes("-f");
  const dryRun = args.includes("--dry-run");
  const addIndex = args.findIndex((a) => a === "--add");
  const additionalCategories = addIndex > -1 ? args[addIndex + 1].split(",") : [];

  // Determine categories
  let categories: string[];
  if (presets[preset]) {
    categories = [...presets[preset], ...additionalCategories];
  } else if (hookTemplates[preset]) {
    categories = ["base", preset, ...additionalCategories];
  } else {
    console.error(`❌ Unknown preset or category: ${preset}`);
    console.log("💡 Use --list to see available options");
    process.exit(1);
  }

  // Generate config
  console.log(`🔧 Generating config with: ${categories.join(", ")}\n`);
  const config = generateConfig(categories);
  const yaml = generateYaml(config);

  if (dryRun) {
    console.log(yaml);
    return;
  }

  // Check existing file
  if (existsSync(outputFile) && !force) {
    console.error(`❌ ${outputFile} already exists`);
    console.log("💡 Use --force to overwrite");
    process.exit(1);
  }

  // Write file
  writeFileSync(outputFile, yaml);
  console.log(`✅ Generated ${outputFile}`);
  console.log(`   Repositories: ${config.repos.length}`);
  const hookCount = config.repos.reduce((acc, r) => acc + r.hooks.length, 0);
  console.log(`   Total Hooks: ${hookCount}`);

  console.log("\n📋 Next steps:");
  console.log("   1. Review the generated configuration");
  console.log("   2. Run: pre-commit install");
  console.log("   3. Test: pre-commit run --all-files");
}

main().catch(console.error);

#!/usr/bin/env bun
/**
 * HookValidator - Validate pre-commit hook configurations
 *
 * Usage:
 *   bun run HookValidator.ts [options]
 *
 * Validates:
 *   - YAML syntax
 *   - Required fields
 *   - Version formats
 *   - Hook availability
 *   - Configuration consistency
 */

import { existsSync, readFileSync } from "fs";
import { parse as parseYaml } from "yaml";
import { $ } from "bun";

interface Hook {
  id: string;
  name?: string;
  alias?: string;
  entry?: string;
  language?: string;
  language_version?: string;
  files?: string;
  exclude?: string;
  types?: string[];
  types_or?: string[];
  exclude_types?: string[];
  args?: string[];
  stages?: string[];
  additional_dependencies?: string[];
  always_run?: boolean;
  pass_filenames?: boolean;
  require_serial?: boolean;
  verbose?: boolean;
  log_file?: string;
}

interface Repo {
  repo: string;
  rev: string;
  hooks: Hook[];
}

interface PreCommitConfig {
  repos: Repo[];
  default_install_hook_types?: string[];
  default_language_version?: Record<string, string>;
  default_stages?: string[];
  files?: string;
  exclude?: string;
  fail_fast?: boolean;
  minimum_pre_commit_version?: string;
}

interface ValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
  info: string[];
}

const CONFIG_FILE = ".pre-commit-config.yaml";

const VALID_STAGES = [
  "pre-commit",
  "pre-merge-commit",
  "pre-push",
  "commit-msg",
  "post-checkout",
  "post-commit",
  "post-merge",
  "post-rewrite",
  "prepare-commit-msg",
  "pre-rebase",
];

const VALID_LANGUAGES = [
  "python",
  "node",
  "ruby",
  "rust",
  "golang",
  "swift",
  "docker",
  "docker_image",
  "dotnet",
  "lua",
  "perl",
  "r",
  "script",
  "system",
  "fail",
  "pygrep",
];

const COMMON_FILE_TYPES = [
  "text",
  "binary",
  "executable",
  "python",
  "javascript",
  "jsx",
  "ts",
  "tsx",
  "json",
  "yaml",
  "toml",
  "xml",
  "html",
  "css",
  "scss",
  "markdown",
  "shell",
  "bash",
  "zsh",
  "go",
  "rust",
  "java",
  "c",
  "cpp",
  "dockerfile",
  "terraform",
  "hcl",
];

function loadConfig(filePath: string): PreCommitConfig | null {
  if (!existsSync(filePath)) {
    console.error(`❌ ${filePath} not found`);
    return null;
  }

  try {
    const content = readFileSync(filePath, "utf-8");
    return parseYaml(content) as PreCommitConfig;
  } catch (error) {
    console.error(`❌ Failed to parse ${filePath}:`, error);
    return null;
  }
}

function validateRegex(pattern: string, fieldName: string): string | null {
  try {
    new RegExp(pattern);
    return null;
  } catch {
    return `Invalid regex in ${fieldName}: ${pattern}`;
  }
}

function validateVersion(rev: string, repoUrl: string): string | null {
  if (repoUrl === "local" || repoUrl === "meta") {
    return null;
  }

  // Valid formats: v1.0.0, v1.0, 1.0.0, commit SHA (7-40 hex chars)
  const versionPattern = /^v?\d+\.\d+(\.\d+)?(-[\w.]+)?$/;
  const shaPattern = /^[a-f0-9]{7,40}$/;

  if (versionPattern.test(rev) || shaPattern.test(rev)) {
    return null;
  }

  return `Suspicious 'rev' format '${rev}' - use version tags (v1.0.0) or commit SHAs`;
}

function validateHook(hook: Hook, repoUrl: string, repoIndex: number, hookIndex: number): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
    info: [],
  };

  const prefix = `Repo ${repoIndex + 1}, Hook ${hookIndex + 1}`;

  // Required: id
  if (!hook.id) {
    result.errors.push(`${prefix}: Missing required 'id' field`);
    result.valid = false;
    return result;
  }

  const hookPrefix = `${prefix} (${hook.id})`;

  // Local hooks require additional fields
  if (repoUrl === "local") {
    if (!hook.name) {
      result.warnings.push(`${hookPrefix}: Local hooks should have a 'name'`);
    }
    if (!hook.entry) {
      result.errors.push(`${hookPrefix}: Local hooks require 'entry'`);
      result.valid = false;
    }
    if (!hook.language) {
      result.errors.push(`${hookPrefix}: Local hooks require 'language'`);
      result.valid = false;
    }
  }

  // Validate language
  if (hook.language && !VALID_LANGUAGES.includes(hook.language.toLowerCase())) {
    result.warnings.push(
      `${hookPrefix}: Unknown language '${hook.language}' - valid: ${VALID_LANGUAGES.join(", ")}`
    );
  }

  // Validate stages
  if (hook.stages) {
    for (const stage of hook.stages) {
      if (!VALID_STAGES.includes(stage)) {
        result.errors.push(
          `${hookPrefix}: Invalid stage '${stage}' - valid: ${VALID_STAGES.join(", ")}`
        );
        result.valid = false;
      }
    }
  }

  // Validate file types
  const allTypes = [...(hook.types || []), ...(hook.types_or || []), ...(hook.exclude_types || [])];
  for (const type of allTypes) {
    if (!COMMON_FILE_TYPES.includes(type)) {
      result.info.push(`${hookPrefix}: Uncommon file type '${type}'`);
    }
  }

  // Validate regex patterns
  if (hook.files) {
    const regexError = validateRegex(hook.files, "files");
    if (regexError) {
      result.errors.push(`${hookPrefix}: ${regexError}`);
      result.valid = false;
    }
  }

  if (hook.exclude) {
    const regexError = validateRegex(hook.exclude, "exclude");
    if (regexError) {
      result.errors.push(`${hookPrefix}: ${regexError}`);
      result.valid = false;
    }
  }

  // Warn about conflicting options
  if (hook.types && hook.types_or) {
    result.warnings.push(
      `${hookPrefix}: Using both 'types' (AND) and 'types_or' (OR) - this may cause confusion`
    );
  }

  if (hook.always_run && hook.files) {
    result.warnings.push(
      `${hookPrefix}: 'always_run: true' with 'files' pattern may be redundant`
    );
  }

  return result;
}

function validateRepo(repo: Repo, index: number): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
    info: [],
  };

  const prefix = `Repo ${index + 1}`;

  // Validate repo URL
  if (!repo.repo) {
    result.errors.push(`${prefix}: Missing 'repo' field`);
    result.valid = false;
    return result;
  }

  const repoPrefix = `${prefix} (${repo.repo})`;

  // Validate rev
  if (repo.repo !== "local" && repo.repo !== "meta") {
    if (!repo.rev) {
      result.errors.push(`${repoPrefix}: Missing 'rev' field`);
      result.valid = false;
    } else {
      const versionWarning = validateVersion(repo.rev, repo.repo);
      if (versionWarning) {
        result.warnings.push(`${repoPrefix}: ${versionWarning}`);
      }
    }
  }

  // Validate hooks
  if (!repo.hooks || repo.hooks.length === 0) {
    result.errors.push(`${repoPrefix}: No hooks defined`);
    result.valid = false;
  } else {
    for (let i = 0; i < repo.hooks.length; i++) {
      const hookResult = validateHook(repo.hooks[i], repo.repo, index, i);
      result.errors.push(...hookResult.errors);
      result.warnings.push(...hookResult.warnings);
      result.info.push(...hookResult.info);
      if (!hookResult.valid) {
        result.valid = false;
      }
    }

    // Check for duplicate hook IDs
    const hookIds = repo.hooks.map((h) => h.id);
    const duplicates = hookIds.filter((id, idx) => hookIds.indexOf(id) !== idx);
    if (duplicates.length > 0) {
      result.warnings.push(
        `${repoPrefix}: Duplicate hook IDs: ${[...new Set(duplicates)].join(", ")}`
      );
    }
  }

  return result;
}

function validateConfig(config: PreCommitConfig): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
    info: [],
  };

  // Validate top-level structure
  if (!config.repos || !Array.isArray(config.repos)) {
    result.errors.push("Missing or invalid 'repos' field");
    result.valid = false;
    return result;
  }

  if (config.repos.length === 0) {
    result.errors.push("No repositories defined");
    result.valid = false;
    return result;
  }

  // Validate default_stages
  if (config.default_stages) {
    for (const stage of config.default_stages) {
      if (!VALID_STAGES.includes(stage)) {
        result.errors.push(`Invalid default_stage '${stage}'`);
        result.valid = false;
      }
    }
  }

  // Validate global patterns
  if (config.files) {
    const regexError = validateRegex(config.files, "files");
    if (regexError) {
      result.errors.push(regexError);
      result.valid = false;
    }
  }

  if (config.exclude) {
    const regexError = validateRegex(config.exclude, "exclude");
    if (regexError) {
      result.errors.push(regexError);
      result.valid = false;
    }
  }

  // Validate each repository
  for (let i = 0; i < config.repos.length; i++) {
    const repoResult = validateRepo(config.repos[i], i);
    result.errors.push(...repoResult.errors);
    result.warnings.push(...repoResult.warnings);
    result.info.push(...repoResult.info);
    if (!repoResult.valid) {
      result.valid = false;
    }
  }

  // Check for duplicate repositories
  const repoUrls = config.repos.map((r) => r.repo);
  const duplicateRepos = repoUrls.filter((url, idx) => repoUrls.indexOf(url) !== idx);
  if (duplicateRepos.length > 0) {
    result.warnings.push(
      `Duplicate repositories: ${[...new Set(duplicateRepos)].join(", ")}`
    );
  }

  return result;
}

async function checkHookAvailability(config: PreCommitConfig): Promise<string[]> {
  const warnings: string[] = [];

  // Try to run pre-commit to check hook availability
  try {
    await $`pre-commit --version`.quiet();
  } catch {
    return ["pre-commit not installed - skipping hook availability check"];
  }

  for (const repo of config.repos) {
    if (repo.repo === "local" || repo.repo === "meta") {
      continue;
    }

    for (const hook of repo.hooks) {
      try {
        // Use try-repo to check if hook exists (dry-run)
        await $`pre-commit try-repo ${repo.repo} --rev ${repo.rev} ${hook.id} --verbose 2>&1`.quiet();
      } catch {
        // Hook might not exist or repo might not be accessible
        warnings.push(`Hook '${hook.id}' from '${repo.repo}' may not be available`);
      }
    }
  }

  return warnings;
}

function printResult(result: ValidationResult, verbose: boolean): void {
  const totalIssues = result.errors.length + result.warnings.length;

  if (result.errors.length > 0) {
    console.log("\n❌ Errors:");
    result.errors.forEach((e) => console.log(`   ${e}`));
  }

  if (result.warnings.length > 0) {
    console.log("\n⚠️  Warnings:");
    result.warnings.forEach((w) => console.log(`   ${w}`));
  }

  if (verbose && result.info.length > 0) {
    console.log("\nℹ️  Info:");
    result.info.forEach((i) => console.log(`   ${i}`));
  }

  console.log("\n" + "─".repeat(50));

  if (result.valid && result.warnings.length === 0) {
    console.log("✅ Configuration is valid!");
  } else if (result.valid) {
    console.log(`✅ Configuration is valid with ${result.warnings.length} warning(s)`);
  } else {
    console.log(`❌ Configuration has ${result.errors.length} error(s)`);
  }
}

function showHelp(): void {
  console.log(`
HookValidator - Validate pre-commit hook configurations

Usage:
  bun run HookValidator.ts [options]

Options:
  --file, -f <path>    Config file path (default: .pre-commit-config.yaml)
  --verbose, -v        Show info messages
  --check-availability Check if hooks are available (slow)
  --json               Output as JSON
  --help, -h           Show this help

Validates:
  - YAML syntax
  - Required fields (repo, rev, id)
  - Version/rev format
  - Stage names
  - Language types
  - Regex patterns
  - Duplicate detection

Examples:
  bun run HookValidator.ts
  bun run HookValidator.ts --verbose
  bun run HookValidator.ts --file custom-config.yaml
  bun run HookValidator.ts --check-availability
`);
}

async function main(): Promise<void> {
  const args = process.argv.slice(2);

  if (args.includes("--help") || args.includes("-h")) {
    showHelp();
    process.exit(0);
  }

  // Parse options
  const fileIndex = args.findIndex((a) => a === "--file" || a === "-f");
  const configFile = fileIndex > -1 ? args[fileIndex + 1] : CONFIG_FILE;
  const verbose = args.includes("--verbose") || args.includes("-v");
  const checkAvailability = args.includes("--check-availability");
  const jsonOutput = args.includes("--json");

  console.log(`🔍 Validating ${configFile}...\n`);

  // Load configuration
  const config = loadConfig(configFile);
  if (!config) {
    process.exit(1);
  }

  // Validate configuration
  const result = validateConfig(config);

  // Check hook availability if requested
  if (checkAvailability) {
    console.log("Checking hook availability (this may take a while)...");
    const availabilityWarnings = await checkHookAvailability(config);
    result.warnings.push(...availabilityWarnings);
  }

  // Output results
  if (jsonOutput) {
    console.log(JSON.stringify(result, null, 2));
  } else {
    // Summary
    console.log("📊 Summary:");
    console.log(`   Repositories: ${config.repos.length}`);
    const hookCount = config.repos.reduce((acc, r) => acc + r.hooks.length, 0);
    console.log(`   Total Hooks: ${hookCount}`);

    printResult(result, verbose);
  }

  process.exit(result.valid ? 0 : 1);
}

main().catch(console.error);

{
  "name": "precommit-tools",
  "version": "1.0.0",
  "description": "TypeScript tools for managing pre-commit configurations",
  "type": "module",
  "scripts": {
    "manager": "bun run PreCommitManager.ts",
    "generator": "bun run HookGenerator.ts",
    "validator": "bun run HookValidator.ts",
    "status": "bun run PreCommitManager.ts status",
    "install": "bun run PreCommitManager.ts install",
    "run": "bun run PreCommitManager.ts run --all-files",
    "update": "bun run PreCommitManager.ts update",
    "validate": "bun run HookValidator.ts",
    "generate:python": "bun run HookGenerator.ts python",
    "generate:javascript": "bun run HookGenerator.ts javascript",
    "generate:terraform": "bun run HookGenerator.ts terraform",
    "generate:minimal": "bun run HookGenerator.ts minimal"
  },
  "dependencies": {
    "yaml": "^2.6.0"
  },
  "devDependencies": {
    "@types/bun": "latest",
    "typescript": "^5.6.0"
  },
  "engines": {
    "bun": ">=1.0.0"
  }
}

#!/usr/bin/env bun
/**
 * PreCommitManager - CLI tool for managing pre-commit configurations
 *
 * Usage:
 *   bun run PreCommitManager.ts <command> [options]
 *
 * Commands:
 *   status     - Show pre-commit installation status
 *   install    - Install pre-commit hooks
 *   run        - Run hooks on files
 *   update     - Update hooks to latest versions
 *   clean      - Clean cached environments
 *   validate   - Validate configuration file
 */

import { $ } from "bun";
import { existsSync, readFileSync } from "fs";
import { parse as parseYaml } from "yaml";

interface Hook {
  id: string;
  name?: string;
  args?: string[];
  files?: string;
  exclude?: string;
  stages?: string[];
  additional_dependencies?: string[];
}

interface Repo {
  repo: string;
  rev: string;
  hooks: Hook[];
}

interface PreCommitConfig {
  repos: Repo[];
  default_stages?: string[];
  fail_fast?: boolean;
  files?: string;
  exclude?: string;
}

const CONFIG_FILE = ".pre-commit-config.yaml";

async function checkPreCommitInstalled(): Promise<boolean> {
  try {
    await $`pre-commit --version`.quiet();
    return true;
  } catch {
    return false;
  }
}

async function getPreCommitVersion(): Promise<string> {
  try {
    const result = await $`pre-commit --version`.text();
    return result.trim();
  } catch {
    return "Not installed";
  }
}

function loadConfig(): PreCommitConfig | null {
  if (!existsSync(CONFIG_FILE)) {
    console.error(`❌ ${CONFIG_FILE} not found`);
    return null;
  }

  try {
    const content = readFileSync(CONFIG_FILE, "utf-8");
    return parseYaml(content) as PreCommitConfig;
  } catch (error) {
    console.error(`❌ Failed to parse ${CONFIG_FILE}:`, error);
    return null;
  }
}

async function status(): Promise<void> {
  console.log("🔍 Pre-commit Status\n");

  // Check installation
  const installed = await checkPreCommitInstalled();
  const version = await getPreCommitVersion();

  console.log(`📦 Pre-commit: ${installed ? "✅ Installed" : "❌ Not installed"}`);
  console.log(`   Version: ${version}`);

  // Check config file
  const configExists = existsSync(CONFIG_FILE);
  console.log(`\n📄 Config: ${configExists ? "✅ Found" : "❌ Not found"}`);

  if (configExists) {
    const config = loadConfig();
    if (config) {
      console.log(`   Repositories: ${config.repos?.length || 0}`);

      const hookCount = config.repos?.reduce(
        (acc, repo) => acc + (repo.hooks?.length || 0),
        0
      ) || 0;
      console.log(`   Total Hooks: ${hookCount}`);

      if (config.default_stages) {
        console.log(`   Default Stages: ${config.default_stages.join(", ")}`);
      }
      if (config.fail_fast) {
        console.log(`   Fail Fast: enabled`);
      }
    }
  }

  // Check git hooks installation
  const gitHooksPath = ".git/hooks/pre-commit";
  const hooksInstalled = existsSync(gitHooksPath);
  console.log(`\n🪝 Git Hooks: ${hooksInstalled ? "✅ Installed" : "❌ Not installed"}`);

  if (!hooksInstalled && configExists) {
    console.log("\n💡 Run 'pre-commit install' to set up git hooks");
  }
}

async function install(options: { installHooks?: boolean }): Promise<void> {
  console.log("📦 Installing pre-commit hooks...\n");

  const installed = await checkPreCommitInstalled();
  if (!installed) {
    console.log("❌ pre-commit is not installed");
    console.log("💡 Install with: pip install pre-commit");
    process.exit(1);
  }

  if (!existsSync(CONFIG_FILE)) {
    console.log(`❌ ${CONFIG_FILE} not found`);
    console.log("💡 Create one with: pre-commit sample-config > .pre-commit-config.yaml");
    process.exit(1);
  }

  try {
    if (options.installHooks) {
      console.log("Installing hooks with dependencies...");
      await $`pre-commit install --install-hooks`;
    } else {
      await $`pre-commit install`;
    }
    console.log("\n✅ Pre-commit hooks installed successfully!");
  } catch (error) {
    console.error("❌ Failed to install hooks:", error);
    process.exit(1);
  }
}

async function run(options: {
  allFiles?: boolean;
  hookId?: string;
  files?: string[];
}): Promise<void> {
  const installed = await checkPreCommitInstalled();
  if (!installed) {
    console.error("❌ pre-commit is not installed");
    process.exit(1);
  }

  const args: string[] = ["run"];

  if (options.hookId) {
    args.push(options.hookId);
  }

  if (options.allFiles) {
    args.push("--all-files");
  }

  if (options.files && options.files.length > 0) {
    args.push("--files", ...options.files);
  }

  console.log(`🚀 Running: pre-commit ${args.join(" ")}\n`);

  try {
    const proc = Bun.spawn(["pre-commit", ...args], {
      stdout: "inherit",
      stderr: "inherit",
    });
    const exitCode = await proc.exited;
    process.exit(exitCode);
  } catch (error) {
    console.error("❌ Hook execution failed");
    process.exit(1);
  }
}

async function update(options: { bleedingEdge?: boolean }): Promise<void> {
  console.log("🔄 Updating pre-commit hooks...\n");

  const installed = await checkPreCommitInstalled();
  if (!installed) {
    console.error("❌ pre-commit is not installed");
    process.exit(1);
  }

  try {
    if (options.bleedingEdge) {
      await $`pre-commit autoupdate --bleeding-edge`;
    } else {
      await $`pre-commit autoupdate`;
    }
    console.log("\n✅ Hooks updated successfully!");
  } catch (error) {
    console.error("❌ Update failed:", error);
    process.exit(1);
  }
}

async function clean(): Promise<void> {
  console.log("🧹 Cleaning pre-commit cache...\n");

  const installed = await checkPreCommitInstalled();
  if (!installed) {
    console.error("❌ pre-commit is not installed");
    process.exit(1);
  }

  try {
    await $`pre-commit clean`;
    console.log("✅ Cache cleaned successfully!");
  } catch (error) {
    console.error("❌ Clean failed:", error);
    process.exit(1);
  }
}

function validate(): void {
  console.log("🔍 Validating pre-commit configuration...\n");

  const config = loadConfig();
  if (!config) {
    process.exit(1);
  }

  const issues: string[] = [];
  const warnings: string[] = [];

  // Validate repos
  if (!config.repos || config.repos.length === 0) {
    issues.push("No repositories defined");
  } else {
    config.repos.forEach((repo, index) => {
      // Check repo URL
      if (!repo.repo) {
        issues.push(`Repo ${index + 1}: Missing 'repo' field`);
      }

      // Check rev (warn if using branch-like names)
      if (!repo.rev) {
        issues.push(`Repo ${index + 1}: Missing 'rev' field`);
      } else if (!repo.rev.startsWith("v") && !repo.rev.match(/^[a-f0-9]{7,40}$/)) {
        if (repo.repo !== "local" && repo.repo !== "meta") {
          warnings.push(
            `Repo ${index + 1} (${repo.repo}): 'rev' should be a version tag or commit SHA, not '${repo.rev}'`
          );
        }
      }

      // Check hooks
      if (!repo.hooks || repo.hooks.length === 0) {
        issues.push(`Repo ${index + 1}: No hooks defined`);
      } else {
        repo.hooks.forEach((hook, hookIndex) => {
          if (!hook.id) {
            issues.push(`Repo ${index + 1}, Hook ${hookIndex + 1}: Missing 'id' field`);
          }
        });
      }
    });
  }

  // Report results
  if (issues.length > 0) {
    console.log("❌ Errors:");
    issues.forEach((issue) => console.log(`   - ${issue}`));
  }

  if (warnings.length > 0) {
    console.log("\n⚠️  Warnings:");
    warnings.forEach((warning) => console.log(`   - ${warning}`));
  }

  if (issues.length === 0 && warnings.length === 0) {
    console.log("✅ Configuration is valid!");
  }

  // Summary
  console.log("\n📊 Summary:");
  console.log(`   Repositories: ${config.repos?.length || 0}`);
  const hookCount =
    config.repos?.reduce((acc, repo) => acc + (repo.hooks?.length || 0), 0) || 0;
  console.log(`   Total Hooks: ${hookCount}`);

  if (issues.length > 0) {
    process.exit(1);
  }
}

function listHooks(): void {
  console.log("📋 Configured Hooks\n");

  const config = loadConfig();
  if (!config) {
    process.exit(1);
  }

  config.repos?.forEach((repo) => {
    const repoName =
      repo.repo === "local"
        ? "local"
        : repo.repo === "meta"
          ? "meta"
          : repo.repo.split("/").slice(-2).join("/");

    console.log(`\n📦 ${repoName} (${repo.rev})`);

    repo.hooks?.forEach((hook) => {
      const name = hook.name || hook.id;
      const stages = hook.stages?.join(", ") || "pre-commit";
      console.log(`   └─ ${hook.id}`);
      if (hook.name && hook.name !== hook.id) {
        console.log(`      Name: ${hook.name}`);
      }
      if (hook.files) {
        console.log(`      Files: ${hook.files}`);
      }
      if (hook.stages) {
        console.log(`      Stages: ${stages}`);
      }
      if (hook.args && hook.args.length > 0) {
        console.log(`      Args: ${hook.args.join(" ")}`);
      }
    });
  });
}

function showHelp(): void {
  console.log(`
Pre-commit Manager - CLI for managing pre-commit configurations

Usage:
  bun run PreCommitManager.ts <command> [options]

Commands:
  status              Show pre-commit installation status
  install             Install pre-commit hooks
    --install-hooks   Also download hook dependencies
  run [hook-id]       Run hooks
    --all-files       Run on all files
    --files <files>   Run on specific files
  update              Update hooks to latest versions
    --bleeding-edge   Use latest commits instead of tags
  clean               Clean cached environments
  validate            Validate configuration file
  list                List configured hooks
  help                Show this help message

Examples:
  bun run PreCommitManager.ts status
  bun run PreCommitManager.ts install --install-hooks
  bun run PreCommitManager.ts run --all-files
  bun run PreCommitManager.ts run black
  bun run PreCommitManager.ts update
  bun run PreCommitManager.ts validate
`);
}

// Main CLI
async function main(): Promise<void> {
  const args = process.argv.slice(2);
  const command = args[0];

  switch (command) {
    case "status":
      await status();
      break;

    case "install":
      await install({
        installHooks: args.includes("--install-hooks"),
      });
      break;

    case "run":
      const hookId = args[1] && !args[1].startsWith("--") ? args[1] : undefined;
      const allFiles = args.includes("--all-files");
      const filesIndex = args.indexOf("--files");
      const files =
        filesIndex > -1 ? args.slice(filesIndex + 1).filter((a) => !a.startsWith("--")) : [];

      await run({ allFiles, hookId, files });
      break;

    case "update":
      await update({
        bleedingEdge: args.includes("--bleeding-edge"),
      });
      break;

    case "clean":
      await clean();
      break;

    case "validate":
      validate();
      break;

    case "list":
      listHooks();
      break;

    case "help":
    case "--help":
    case "-h":
      showHelp();
      break;

    default:
      if (command) {
        console.error(`Unknown command: ${command}\n`);
      }
      showHelp();
      process.exit(command ? 1 : 0);
  }
}

main().catch(console.error);