Skip to content

README.hi.md

Latest commit

 

History

History
157 lines (123 loc) · 9.93 KB

README.hi.md

File metadata and controls

157 lines (123 loc) · 9.93 KB
Raw

grit

AI एजेंट्स के लिए Git — शून्य मर्ज कॉन्फ्लिक्ट, कितने भी पैरेलल एजेंट, एक ही कोडबेस।

जब 50 एजेंट एक ही रिपो पर काम करते हैं, तो git टूट जाता है। Grit नहीं टूटता।

Read in English: README.md

बेंचमार्क परिणाम (5 इटरेशन x 5 राउंड)

Agents │ Git Merge Failures │ Grit Merge Failures │ Git Conflict Files
───────┼────────────────────┼─────────────────────┼───────────────────
     1 │         0  (0%)    │         0  (0%)     │        0
     2 │         5  (50%)   │         0  (0%)     │       38
     5 │        20  (80%)   │         0  (0%)     │       80
    10 │        43  (86%)   │         0  (0%)     │       90
    20 │        83  (83%)   │         0  (0%)     │      130
    50 │       175  (70%)   │         0  (0%)     │      175

Grit: सभी 1,500 मर्ज प्रयासों में 0 कॉन्फ्लिक्ट।

यह कैसे काम करता है

                        समस्या
  ┌─────────────────────────────────────────────────┐
  │  10 AI एजेंट अलग-अलग फंक्शन एडिट करते हैं     │
  │  एक ही फाइल (auth.ts) में                       │
  │                                                 │
  │  Git देखता है: एक ही फाइल 10 ब्रांच पर बदली     │
  │  परिणाम:      O(N²) मर्ज कॉन्फ्लिक्ट           │
  └─────────────────────────────────────────────────┘

                        समाधान
  ┌─────────────────────────────────────────────────┐
  │  Grit फंक्शन लेवल (AST) पर लॉक करता है          │
  │  फाइल लेवल (लाइन) पर नहीं                      │
  │                                                 │
  │  Agent-1 लॉक करता है: validateToken()            │
  │  Agent-2 लॉक करता है: refreshToken()             │
  │  → एक ही फाइल, अलग फंक्शन, शून्य कॉन्फ्लिक्ट  │
  └─────────────────────────────────────────────────┘

  ┌──────────┐    ┌──────────┐    ┌──────────┐
  │ 1. CLAIM │───▶│ 2. WORK  │───▶│ 3. DONE  │
  │          │    │          │    │          │
  │ Lock AST │    │ Parallel │    │ Rebase + │
  │ symbols  │    │ worktrees│    │ Merge    │
  └──────────┘    └──────────┘    └──────────┘
       │               │               │
       ▼               ▼               ▼
  ┌──────────┐    ┌──────────┐    ┌──────────┐
  │ SQLite   │    │ .grit/   │    │ Serial   │
  │ या S3    │    │ worktrees│    │ file lock│
  │ lock DB  │    │ /agent-N │    │ → merge  │
  └──────────┘    └──────────┘    └──────────┘

आर्किटेक्चर

┌─────────────────────────────────────────┐
│              आपका git रिपो              │
├─────────────────────────────────────────┤
│  .grit/                                 │
│  ├── registry.db    (SQLite WAL)        │  ← सिंबल इंडेक्स + लॉक टेबल
│  ├── config.json                        │  ← बैकएंड कॉन्फिग (लोकल/S3)
│  ├── room.sock      (Unix socket)       │  ← रियल-टाइम इवेंट स्ट्रीम
│  ├── merge.lock     (RAII फाइल लॉक)    │  ← git मर्ज को सीरियलाइज़ करता है
│  └── worktrees/                         │
│      ├── agent-1/   (git worktree)      │  ← आइसोलेटेड वर्किंग डायरेक्टरी
│      ├── agent-2/   (git worktree)      │
│      └── agent-N/   ...                 │
├─────────────────────────────────────────┤
│  बैकएंड:                                │
│  ├── लोकल: SQLite WAL (डिफॉल्ट)        │
│  ├── AWS S3 (conditional PUT)           │
│  ├── Cloudflare R2                      │
│  ├── Google Cloud Storage               │
│  ├── Azure Blob Storage                 │
│  └── MinIO (सेल्फ-होस्टेड)             │
└─────────────────────────────────────────┘

समस्या

एक कोडबेस पर N AI एजेंट्स को समानांतर चलाने से O(N²) मर्ज कॉन्फ्लिक्ट बनते हैं। Git लाइन लेवल पर काम करता है — जब दो एजेंट एक ही फाइल में अलग-अलग फंक्शन एडिट करते हैं, तो Git कॉन्फ्लिक्टिंग हंक देखता है और मर्ज फेल हो जाता है।

समाधान

Grit tree-sitter का उपयोग करके AST/फंक्शन लेवल पर लॉक करता है। हर एजेंट एडिट करने से पहले विशिष्ट फंक्शन रिज़र्व करता है। एक ही फाइल में अलग-अलग फंक्शन कभी कॉन्फ्लिक्ट नहीं करते। एजेंट आइसोलेटेड git worktree में काम करते हैं और मर्ज ऑटोमैटिकली सीरियलाइज़ होते हैं।

इंस्टॉलेशन

cargo install --git https://github.com/rtk-ai/grit

क्विक स्टार्ट

cd your-project
grit init                    # AST पार्स करें, सिंबल इंडेक्स बनाएं

# एजेंट एडिट करने से पहले फंक्शन रिज़र्व करता है
grit claim -a agent-1 -i "वैलिडेशन जोड़ें" \
  src/auth.ts::validateToken \
  src/auth.ts::refreshToken

# एजेंट आइसोलेटेड worktree में काम करता है: .grit/worktrees/agent-1/
# ... फाइलें एडिट करें ...

# पूरा: ऑटो-कमिट, रीबेस, मर्ज, लॉक रिलीज़
grit done -a agent-1

सेशन वर्कफ़्लो (GitHub इंटीग्रेशन)

grit session start auth-refactor        # ब्रांच grit/auth-refactor बनाएं
# ... एजेंट claim, काम, done ...
grit session pr                         # ब्रांच push + GitHub PR बनाएं
grit session end                        # लॉक क्लीनअप, बेस ब्रांच पर वापस

कमांड

grit init                                    # सिंबल इंडेक्स इनिशियलाइज़ करें
grit claim -a <agent> -i <intent> <syms...>  # सिंबल लॉक + worktree बनाएं
grit done  -a <agent>                        # मर्ज + लॉक रिलीज़
grit status                                  # एक्टिव लॉक दिखाएं
grit symbols [--file <pattern>]              # इंडेक्स किए सिंबल की सूची
grit plan <symbols...>                       # उपलब्धता जांचें (dry-run)
grit release -a <agent> <symbols...>         # विशिष्ट लॉक रिलीज़ करें
grit gc                                      # एक्सपायर्ड लॉक क्लीन करें
grit heartbeat -a <agent>                    # लॉक TTL रिफ्रेश करें
grit watch                                   # रियल-टाइम इवेंट स्ट्रीम
grit session start|status|pr|end             # फीचर ब्रांच लाइफसाइकल
grit config set-s3|set-local|show            # बैकएंड कॉन्फिगरेशन

समर्थित भाषाएं

TypeScript, JavaScript, Rust, Python (tree-sitter ग्रामर के ज़रिए विस्तारयोग्य)

लाइसेंस

MIT — Copyright (c) 2026 Patrick Szymkowiak