Pre-commit hooks మరియు ఆటోమేటెడ్ dependency updates అమలు చేయండి

పరిచయం

ఒక repo లో పరిశీలించని commits పేరుకుపోవడాన్ని, నిర్వహణ లేని డిపెండెన్సీ drift ను మీరు అనుమతిస్తే, ప్రతి pull request సంబంధం లేని lint శబ్దంతో పోరాడాల్సి వస్తుంది, ప్రతి త్రైమాసిక అప్‌గ్రేడ్ బహుళ-వారాల అగ్నిమాపక పోరాటంగా మారుతుంది — ఏదో ఒక సమయంలో ఒక డెవలపర్ API key ను, తప్పుగా రూపొందించిన prompt JSON ను, లేదా 200 MB checkpoint ను commit చేస్తారు, ప్రొడక్షన్ విరిగిపోయే వరకు దాన్ని ఎవరూ పట్టుకోరు. ఈ రెండు రకాల వైఫల్యాలను నివారించే అత్యంత చౌకైన రెండు నియంత్రణలు pre-commit hooks మరియు Renovate: hooks చెడు commits remote కు చేరకముందే అడ్డుకుంటాయి, Renovate ఏదైనా కొత్త వెర్షన్ ప్రచురితమైన ప్రతిసారీ లేబుల్ చేసిన PR ను తెరవడం ద్వారా డిపెండెన్సీ ఉపరితలాన్ని నిజాయితీగా ఉంచుతుంది. ఈ పాఠం ముగిసేసరికి, prompt JSON, JSONL training rows, మరియు secrets ను పరిశీలించే .pre-commit-config.yaml ను, అలాగే LLM SDK bumps ను dev-dependency patches కంటే భిన్నంగా పరిగణించే package rules కలిగిన renovate.json ను మీరు రచించగలరు.

ముఖ్య పదజాలం

• Pre-commit framework — .pre-commit-config.yaml లో ప్రకటించిన hooks ను సమన్వయపరిచే Python సాధనం (pre-commit); push కు ముందు స్థానికంగా చెడు commits ను అడ్డుకోవడానికి ప్రతి డెవలపర్ నడిపే ఏకైక యంత్రాంగం ఇదే కాబట్టి ఇక్కడ ముఖ్యమైనది.
• Hook repository — దీని .pre-commit-hooks.yaml పునర్వినియోగించదగిన hook నిర్వచనాలను (id, language, files pattern, entry command) బహిర్గతం చేసే ఒక Git repo; సాధారణ తనిఖీలను మళ్లీ అమలు చేయకుండా ఉండటానికి వీటిని మీ config లో కూర్చుతారు.
• Renovate — npm, PyPI, Docker, Helm, లేదా GitHub Action వెర్షన్‌లు మారినప్పుడు PRs తెరిచే ఒక dependency-update bot; డిపెండెన్సీ అప్‌గ్రేడ్‌లు త్రైమాసిక అగ్నిమాపక పోరాటంగా కాకుండా స్థిరమైన బిందువులుగా మారే యంత్రాంగం ఇదే.
• Package rule — ప్యాకేజీల ఉపసమితిని ఎంచుకుని defaults ను (schedule, automerge, group name) అధిగమించే ఒక Renovate config బ్లాక్; AI-నిర్దిష్ట విధానం నివసించే స్థలం, ఉదా. "LLM SDKs ను ఎప్పుడూ auto-merge చేయవద్దు."
• Automerge — status checks విజయవంతమైన తర్వాత bot ఒక PR ను merge చేయడానికి అనుమతించే Renovate సెట్టింగ్; dev-dependency patches వంటి తక్కువ-ప్రమాద అప్‌డేట్ తరగతులకు మాత్రమే కేటాయించబడింది.

భావనలు

మూడు-పొరల pre-commit కాన్ఫిగరేషన్

ఉపయోగకరమైన pre-commit config కు ఒక నిర్మాణాత్మక పొర (whitespace, పెద్ద ఫైళ్లు, YAML/JSON సరైన రూపం), ఒక భాష పొర (Python కోసం Ruff, formatters), మరియు ఒక AI-నిర్దిష్ట పొర (prompt JSON schemas, JSONL row validators, secret detection) ఉంటాయి. సంబంధం లేని commits పనిని దాటవేసేలా ప్రతి hook ఒక files: regex ను ప్రకటిస్తుంది. పూర్తి ఫైల్ repo root లో commit చేయబడుతుంది మరియు git hook ను అనుసంధానించడానికి ప్రతి డెవలపర్ ఒకసారి pre-commit install నడుపుతారు — కూర్చిన ఫైల్ కోసం కోడ్ వాక్‌త్రూ చూడండి.

Hook ప్రవాహం మరియు re-staging

విఫలమైన hook కేవలం error ను ముద్రించడంతో ఆగదు: స్వయంచాలకంగా సరిచేసే hooks (trailing whitespace, Ruff --fix) మార్చిన ఫైళ్లను re-stage చేస్తాయి, తద్వారా తదుపరి git add -u && git commit సాధారణంగా మరింత మానవ చర్య లేకుండానే విజయవంతమవుతుంది. ఇదే hooks ను చికాకు కలిగించేవిగా కాకుండా అలవాటుగా మార్చేది.

AI codebases కోసం Renovate package rules

Renovate యొక్క defaults ఒక సాధారణ web app ను ఊహిస్తాయి. AI ప్రాజెక్టులు మూడు చోట్ల భిన్నంగా ఉంటాయి: (a) LLM SDK bumps ఎప్పుడూ auto-merge కాకూడదు, ఎందుకంటే ఒక minor release tokenization ను లేదా default sampling ను మార్చగలదు — వాటికి ముందుగా evaluation suite నడపాలి; (b) queue ను చిన్నగా ఉంచడానికి dev-dependency patch/minor bumps దూకుడుగా auto-merge కావాలి; (c) ఒకే security advisory ప్రతి service ద్వారా ఒకే PR లో ప్రవహించేలా Docker base image అప్‌డేట్‌లను సమూహపరచాలి. దీని యంత్రాంగం packageRules — కోడ్ వాక్‌త్రూ చూడండి.

GitHub Actions కోసం supply-chain pinning

uses: actions/checkout@v4 అనేది కదిలే లక్ష్యం — రాజీపడిన tag మీ build ను హానికరమైన కోడ్ వైపు మళ్లిస్తుంది. Renovate యొక్క pinDigests: true ప్రతి action సూచనను 40-అక్షరాల commit SHA గా తిరగరాస్తుంది, వెర్షన్‌ను చివర comment గా ఉంచుతుంది, మరియు నిజమైన releases పై SHA ను bump చేస్తూనే ఉంటుంది.

కోడ్ వాక్‌త్రూ

కింది రెండు ఫైళ్లు భావనలలో వివరించిన మూడు-పొరల hook config ను మరియు package-rule విధానాన్ని కూర్చుతాయి. వాటిని repo root కు కాపీ చేయండి, ఒకసారి pre-commit install నడపండి, మరియు repository పై Renovate ను ప్రారంభించండి.

Code snippetyaml
1# .pre-commit-config.yaml
2repos:
3  - repo: https://github.com/pre-commit/pre-commit-hooks
4    rev: v4.6.0
5    hooks:
6      - id: trailing-whitespace
7      - id: end-of-file-fixer
8      - id: check-merge-conflict
9      - id: check-added-large-files
10        args: ['--maxkb=1024']
11      - id: check-yaml
12        args: ['--unsafe']
13      - id: check-json
14
15  - repo: https://github.com/astral-sh/ruff-pre-commit
16    rev: v0.5.7
17    hooks:
18      - id: ruff
19        args: ['--fix']
20      - id: ruff-format
21
22  - repo: https://github.com/Yelp/detect-secrets
23    rev: v1.5.0
24    hooks:
25      - id: detect-secrets
26        args: ['--baseline', '.secrets.baseline']
27        exclude: package-lock\.json|\.ipynb$
28
29  - repo: local
30    hooks:
31      - id: prompt-json-schema
32        name: Validate prompt JSON files against schema
33        entry: python scripts/hooks/validate_prompt_schema.py
34        language: python
35        files: ^prompts/.*\.json$
36        additional_dependencies: [pydantic>=2.7]
37      - id: jsonl-row-validate
38        name: Validate JSONL training data rows
39        entry: python scripts/hooks/validate_jsonl.py
40        language: python
41        files: ^data/training/.*\.jsonl$
42        additional_dependencies: [pydantic>=2.7]

నిర్మాణాత్మక బ్లాక్ (pre-commit-hooks) సాధారణ లోపాలను పట్టుకుంటుంది మరియు — AI repos కు కీలకంగా — checkpoints దొంగచాటుగా చేరకుండా 1 MB కంటే పెద్ద commits ను తిరస్కరిస్తుంది. check-yaml పై --unsafe అనేది {{ .Values.foo }} వంటి Helm templating ను అనుమతిస్తుంది. Ruff బ్లాక్ Black + isort + flake8 ను ఒకే Rust binary తో భర్తీ చేస్తుంది, కాబట్టి PR diff శబ్దంగా ఉండటానికి style ఎప్పుడూ కారణం కాదు. detect-secrets staged ఫైళ్లను .secrets.baseline కు వ్యతిరేకంగా స్కాన్ చేస్తుంది, ఇది తెలిసిన false positives ను నమోదు చేస్తుంది; package-lock.json మరియు .ipynb వాటి అధిక-entropy కంటెంట్ detector ను ట్రిగ్గర్ చేస్తుంది కాబట్టి మినహాయించబడ్డాయి. local బ్లాక్ AI-నిర్దిష్ట పొర: prompt-json-schema అనేది prompts/ కింద ఉన్న ప్రతి ఫైల్‌ను Pydantic model కు వ్యతిరేకంగా ధృవీకరిస్తుంది, మరియు jsonl-row-validate ప్రతి training JSONL లోని ప్రతి లైన్‌ను parse చేసి row schema ను నిర్ధారిస్తుంది.

Code snippetjson
1{
2  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3  "extends": ["config:recommended", ":semanticCommits"],
4  "schedule": ["after 7am every weekday"],
5  "timezone": "America/Los_Angeles",
6  "labels": ["dependencies"],
7  "prHourlyLimit": 4,
8  "prConcurrentLimit": 12,
9  "packageRules": [
10    {
11      "description": "Never auto-merge AI SDK packages",
12      "matchPackagePatterns": ["^openai", "^anthropic", "^google-generativeai", "^langchain", "^llama-index"],
13      "automerge": false,
14      "labels": ["dependencies", "ai-sdk", "needs-evaluation"]
15    },
16    {
17      "description": "Auto-merge dev-dependency patch + minor",
18      "matchDepTypes": ["devDependencies"],
19      "matchUpdateTypes": ["patch", "minor"],
20      "automerge": true,
21      "automergeType": "branch"
22    },
23    {
24      "description": "Group Docker base image updates",
25      "matchDatasources": ["docker"],
26      "groupName": "docker base images"
27    },
28    {
29      "description": "Pin GitHub Actions to commit SHA",
30      "matchDepTypes": ["action"],
31      "pinDigests": true
32    }
33  ]
34}

config:recommended అనేది Renovate యొక్క క్యూరేటెడ్ baseline ను ఎంచుకుంటుంది; :semanticCommits PR శీర్షికలు changelog generators లో శుభ్రంగా parse అయ్యేలా చేస్తుంది. వారపు రోజుల schedule మరియు రెండు పరిమితులు bot శబ్దాన్ని నియంత్రిస్తాయి — అవి లేకపోతే కొత్త repo యాభై open PRs తో మేల్కొంటుంది మరియు బృందం bot ను విస్మరించడం నేర్చుకుంటుంది. నాలుగు package rules AI-నిర్దిష్ట విధానాన్ని ఎన్‌కోడ్ చేస్తాయి: SDK bumps needs-evaluation ను కలిగి ఉంటాయి మరియు auto-merge ను తిరస్కరిస్తాయి; dev-dependency patches GitHub యొక్క branch protection ద్వారా auto-merge అవుతాయి; Docker base images సమూహపరచబడతాయి; actions digests కు pin అవుతాయి.

ఇది పనిచేస్తుందని మీకు తెలిసేది: (a) శుభ్రమైన checkout పై pre-commit run --all-files 0 తో నిష్క్రమించినప్పుడు, (b) test branch పై ఉంచిన నకిలీ secret ను hook తిరస్కరించినప్పుడు, (c) Renovate యొక్క onboarding PR merge అయినప్పుడు, మరియు (d) openai bump needs-evaluation తో తెరుచుకుని auto-merge ను తిరస్కరిస్తుండగా, devDependencies patch bump status checks విజయవంతమైన తర్వాత auto-merge అయినప్పుడు.

కోసం ఆచరణలో

కోడ్ వాక్‌త్రూ ఆధారంగా, అదే రెండు ఫైళ్లు రోజువారీ discipline-నిర్దిష్ట పనికి ఆధారంగా నిలుస్తాయి — మారేది ఏమిటంటే ఏ hooks తమ విలువను నిరూపించుకుంటాయి మరియు ఏ Renovate rules అత్యధిక ట్రాఫిక్‌ను చూస్తాయి అనేదే.

చేయవలసినవి మరియు చేయకూడనివి

చేయవలసినవి

1. CI లో pre-commit run --all-files నడపండి — pre-commit install ను దాటవేసిన డెవలపర్లు ఇప్పటికీ ఉల్లంఘించే commits ను push చేస్తారు; CI దశ PR సమయంలో నియమాలను దాటవేయలేనివిగా చేస్తుంది.
2. GitHub Actions ను commit SHA ద్వారా pin చేయండి — tag hijacking నిజమైన supply-chain దాడి; digest bumps ను Renovate నిర్వహించనివ్వండి, తద్వారా pinning కు మీకు ఏ ఖర్చూ ఉండదు.
3. secret detection ను త్రైమాసికంగా re-baseline చేయండి — .secrets.baseline ఎంట్రీలను పేరుకుపోనిస్తుంది; పాత baseline పాత false-positive లైన్‌తో సరిపోలే నిజమైన leak ను కప్పిపుచ్చగలదు.

చేయకూడనివి

1. model ప్రవర్తనను తాకే దేనినీ auto-merge చేయవద్దు — LLM SDKs, tokenizers, prompt templates; minor bumps రాత్రికి రాత్రే sampling defaults ను మార్చగలవు, కాబట్టి evaluation run ను తప్పనిసరి చేయండి.
2. Renovate queue రెండు పేజీలకు మించి పెరగనివ్వవద్దు — అలా జరిగినప్పుడు, బృందం సమీక్షించడం ఆపేసిందని అర్థం; schedule ను పాజ్ చేయండి, queue ను ఖాళీ చేయండి, ఆపై పునఃప్రారంభించండి.
3. custom hooks పై files: regex ను దాటవేయవద్దు — అది లేకుండా, ప్రతి commit ప్రతి validator ను నడుపుతుంది మరియు ఆ latency పన్ను డెవలపర్లను --no-verify తో hooks ను దాటవేయడానికి అలవాటు చేస్తుంది.