Pre-commit hooks અને ઓટોમેટેડ dependency અપડેટ્સ અમલમાં મૂકો

પરિચય

જ્યારે તમે repo માં તપાસ્યા વગરના commits અને અનિયંત્રિત dependency drift જમા થવા દો છો, ત્યારે દરેક pull request અસંબંધિત lint noise સામે લડે છે અને દરેક ત્રિમાસિક upgrade અનેક અઠવાડિયાંની આગ બુઝાવવાની કવાયત બની જાય છે — અને ક્યારેક કોઈ developer API key, ખોટી રચનાવાળું prompt JSON, અથવા 200 MB નું checkpoint commit કરી દે છે જે production તૂટે ત્યાં સુધી કોઈ પકડતું નથી. Pre-commit hooks અને Renovate એ બે સૌથી સસ્તાં નિયંત્રણો છે જે નિષ્ફળતાના આ બંને વર્ગોને રોકે છે: hooks ખરાબ commits ને remote પર પહોંચતાં પહેલાં અટકાવે છે, અને Renovate જ્યારે પણ કોઈ પેકેજ નવી આવૃત્તિ પ્રકાશિત કરે ત્યારે labelled PR ખોલીને dependency surface ને પ્રમાણિક રાખે છે. આ પાઠના અંતે તમે એવી .pre-commit-config.yaml લખી શકશો જે prompt JSON, JSONL training rows અને secrets ની તપાસ કરે, અને એવી renovate.json જેના package rules LLM SDK bumps ને dev-dependency patches થી અલગ રીતે વર્તે.

મુખ્ય પરિભાષા

• Pre-commit framework — Python ટૂલ (pre-commit) જે .pre-commit-config.yaml માં જાહેર કરેલા hooks નું સંચાલન કરે છે; અહીં સંબંધિત છે કારણ કે આ એક જ પદ્ધતિ છે જે દરેક developer push પહેલાં સ્થાનિક રીતે ખરાબ commits અટકાવવા માટે ચલાવે છે.
• Hook repository — એક Git repo જેની .pre-commit-hooks.yaml પુનઃઉપયોગી hook વ્યાખ્યાઓ (id, language, files pattern, entry command) રજૂ કરે છે; સામાન્ય તપાસોને ફરીથી અમલમાં મૂકવાનું ટાળવા તમે આને તમારા config માં જોડો છો.
• Renovate — એક dependency-update bot જે npm, PyPI, Docker, Helm, અથવા GitHub Action ની આવૃત્તિઓ બદલાય ત્યારે PRs ખોલે છે; આ એ પદ્ધતિ છે જેના દ્વારા dependency upgrades ત્રિમાસિક આગ બુઝાવવાની કવાયતને બદલે સતત ટપકતો પ્રવાહ બની જાય છે.
• Package rule — Renovate config નો એક block જે packages નો ઉપસમૂહ પસંદ કરે છે અને defaults (schedule, automerge, group name) ને override કરે છે; આ એ જગ્યા છે જ્યાં AI-વિશિષ્ટ નીતિ રહે છે, દા.ત. "LLM SDKs ને કદી auto-merge ન કરો."
• Automerge — Renovate ની એક સેટિંગ જે status checks પાસ થયા પછી bot ને PR merge કરવા દે છે; dev-dependency patches જેવા ઓછા જોખમવાળા અપડેટ વર્ગો માટે આરક્ષિત.

વિભાવનાઓ

ત્રણ-સ્તરીય pre-commit configuration

ઉપયોગી pre-commit config માં એક structural સ્તર (whitespace, મોટી ફાઇલો, YAML/JSON ની સુયોગ્ય રચના), એક language સ્તર (Python માટે Ruff, formatters), અને એક AI-વિશિષ્ટ સ્તર (prompt JSON schemas, JSONL row validators, secret detection) હોય છે. દરેક hook files: regex જાહેર કરે છે જેથી અસંબંધિત commits કામ છોડી દે. સંપૂર્ણ ફાઇલ repo ના root પર commit થાય છે અને દરેક developer git hook જોડવા માટે એક વાર pre-commit install ચલાવે છે — એસેમ્બલ થયેલી ફાઇલ માટે Code Walkthrough જુઓ.

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) dev-dependency patch/minor bumps queue ટૂંકી રાખવા માટે આક્રમક રીતે auto-merge થવા જોઈએ; (c) Docker base image અપડેટ્સને group કરવા જોઈએ જેથી એક જ security advisory એક PR માં દરેક service માં ફેલાય. પદ્ધતિ packageRules છે — Code Walkthrough જુઓ.

GitHub Actions માટે supply-chain pinning

uses: actions/checkout@v4 એક ફરતું લક્ષ્ય છે — ચેડાં થયેલો tag તમારા build ને દુર્ભાવનાપૂર્ણ code તરફ ફરીથી નિર્દેશિત કરે છે. Renovate નું pinDigests: true દરેક action reference ને 40-અક્ષરના commit SHA માં ફરીથી લખે છે અને આવૃત્તિને પાછળ comment તરીકે રાખે છે, અને વાસ્તવિક releases પર SHA ને bump કરવાનું ચાલુ રાખે છે.

Code Walkthrough

નીચેની બે ફાઇલો વિભાવનાઓમાં વર્ણવેલ ત્રણ-સ્તરીય hook config અને package-rule નીતિને એસેમ્બલ કરે છે. તેમને repo ના root પર copy કરો, એક વાર 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]

Structural block (pre-commit-hooks) રોજિંદી ખામીઓ પકડે છે અને — AI repos માટે નિર્ણાયક રીતે — 1 MB થી મોટા commits ને નકારે છે જેથી checkpoints છૂપી રીતે દાખલ ન થાય. check-yaml પર --unsafe {{ .Values.foo }} જેવા Helm templating ને મંજૂરી આપે છે. Ruff block Black + isort + flake8 ને એક જ Rust binary થી બદલે છે, જેથી PR diff ઘોંઘાટિયું હોવાનું કારણ કદી style ન બને. detect-secrets staged ફાઇલોને .secrets.baseline સામે સ્કેન કરે છે, જે જાણીતા false positives નોંધે છે; package-lock.json અને .ipynb બાકાત રાખ્યા છે કારણ કે તેમની high-entropy સામગ્રી detector ને છેતરે છે. local block AI-વિશિષ્ટ સ્તર છે: prompt-json-schema prompts/ હેઠળની દરેક ફાઇલને Pydantic model સામે validate કરે છે, અને jsonl-row-validate દરેક training JSONL ની દરેક line 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 થવા યોગ્ય બનાવે છે. Weekday schedule અને બે limits bot ના ઘોંઘાટને મર્યાદિત કરે છે — તેમના વગર નવું repo પચાસ ખુલ્લા PRs સાથે જાગે છે અને ટીમ bot ને અવગણવાનું શીખી જાય છે. ચાર package rules AI-વિશિષ્ટ નીતિને encode કરે છે: SDK bumps needs-evaluation ધરાવે છે અને auto-merge નો ઇનકાર કરે છે; dev-dependency patches GitHub ના branch protection દ્વારા auto-merge થાય છે; Docker base images group થાય છે; actions digests પર pin થાય છે.

તમે જાણશો કે તે કામ કરે છે જ્યારે (a) સ્વચ્છ checkout પર pre-commit run --all-files 0 સાથે exit થાય, (b) test branch પર મૂકેલું નકલી secret hook દ્વારા નકારાય, (c) Renovate નો onboarding PR merge થઈ ગયો હોય, અને (d) openai નો bump needs-evaluation સાથે ખૂલે અને auto-merge નો ઇનકાર કરે જ્યારે devDependencies નો patch bump status checks પાસ થયા પછી auto-merge થાય.

માટે વ્યવહારમાં

Code Walkthrough પર આધાર રાખીને, આ જ બે ફાઇલો રોજિંદા શિસ્ત-વિશિષ્ટ કામનો આધાર બને છે — જે બદલાય છે તે એ છે કે કયા hooks પોતાની કિંમત વસૂલ કરે છે અને કયા Renovate rules સૌથી વધુ ટ્રાફિક જુએ છે.

શું કરવું અને શું ન કરવું

શું કરવું

1. CI માં pre-commit run --all-files ચલાવો — જે developers એ pre-commit install છોડી દીધું હોય તેઓ હજી પણ નિયમભંગ કરતા commits push કરશે; CI step નિયમોને PR સમયે અનિવાર્ય બનાવે છે.
2. GitHub Actions ને commit SHA દ્વારા pin કરો — tag hijacking એક વાસ્તવિક supply-chain હુમલો છે; Renovate ને digest bumps નું સંચાલન કરવા દો જેથી pinning તમને કશું ખર્ચે નહીં.
3. Secret detection ને દર ત્રિમાસિકે re-baseline કરો — .secrets.baseline માં entries જમા થાય છે; જૂનું baseline એવું વાસ્તવિક leak છુપાવી શકે છે જે યોગાનુયોગ જૂની false-positive line સાથે મેળ ખાય.

શું ન કરવું

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 નો બોજ developers ને --no-verify થી hooks ને બાયપાસ કરવાની તાલીમ આપે છે.