तुम्ही जे मागत होता ते शेवटी आले! राल्फ TUI, व्हिज्युअलाइज्ड राल्फ लूप

मी यापूर्वी ralph-loop बद्दल एक ट्युटोरियल लिहिले होते, ते वाचून झाल्यावर बर्‍याच मित्रांनी एकसारखेच मत दिले: मजा आहे, Claude Code शेवटी जास्त वेळ चालू शकतो. पण कधीकधी ते स्थिर दिसते, आणि मनात शंका येते: "हे पुढे जात आहे की एकाच जागी फिरत आहे?"

यामुळेच मी अलीकडे ralph-tui वर काम करत आहे.

ralph-tui Claude Code ला बांधिल नाही, ते राल्फ लूपचा वारसा पुढे नेते आणि कार्य अंमलबजावणी आणि प्रक्रिया व्हिज्युअलाइज करते, ज्यामुळे मोठ्या मॉडेलला जास्त वेळ काम करणे सोपे होते. तुम्ही इतर एजंट, इतर मॉडेल वापरू शकता, जसे की स्वदेशी, स्वस्त आणि दीर्घकाळ चालवता येतील असे. राल्फ-tui मुळे, सामान्य माणसांसाठी, मॅन्युअल गिअरऐवजी ऑटोमॅटिक गिअर आणि क्रूझ कंट्रोल मिळाल्यासारखे आहे.

हे नक्की काय आहे?

तुम्ही राल्फ-tui ला "AI कोडिंग एजंटचा लूप ऑर्केस्ट्रेटर" समजू शकता, जो फक्त "चालू शकतो" यावर समाधानी नाही, तर त्याला "तुम्ही पाहू शकता, नियंत्रित करू शकता आणि पुन्हा सुरू करू शकता" यात अधिक रस आहे.

हे मूलभूतपणे खालीलप्रमाणे कार्य करते:

• तुम्ही त्याला अनेक कार्ये देता (PRD मधून किंवा इतर कार्य प्रणालीतून)
• ते सर्वोच्च प्रा priority चे कार्य निवडते
• प्रॉम्प्ट एकत्र करते
• एजंटला कार्यान्वित करते
• हे कार्य पूर्ण झाले आहे की नाही हे तपासते
• स्थिती जतन करते
• पुढील फेरी सुरू करते

महत्वाचे म्हणजे: हे सर्व तुम्ही टर्मिनलमध्ये पाहू शकता आणि कधीही थांबवू शकता किंवा ताब्यात घेऊ शकता. अधिकृतपणे याची व्याख्या 'interative TUI agent loop orchestrator' अशी केली आहे, आणि ते TUI / headless / remote ला सपोर्ट करते.

मी असे का म्हणतो की ते "दीर्घकाळ चालवण्यासाठी" अधिक योग्य आहे?

स्क्रिप्ट लूप चालवण्याची सर्वात मोठी समस्या ही नाही की ती सुरू होत नाही, तर ती कोठे पोहोचली आहे हे तुम्हाला माहीत नसते.

तुम्ही लॉग्स वेगाने स्क्रोल होताना पाहता, पंखा आनंदाने फिरतो, पण तुम्हाला खात्री नसते:

• ते समान बग वारंवार दुरुस्त करत आहे का?
• ते सतत कोडचा एक भाग बदलत आहे आणि नंतर तो परत बदलत आहे का?
• ते पूर्ण झाले आहे, पण बाहेर पडले नाही?
• ते एखाद्या चाचणीत अडकले आहे आणि डेडलॉक झाले आहे?

राल्फ-tui चा उपाय खूप "engineering" प्रकारचा आहे:

• यात सेशनची संकल्पना आहे, स्थिती डिस्कवर जतन केली जाते (.ralph-tui/session.json)
• क्रॅश झाल्यास पुन्हा सुरू करता येते (crash recovery)
• यात लॉक यंत्रणा आहे, ज्यामुळे तुम्ही अनेक इंस्टन्स उघडून डिरेक्टरी गोंधळात टाकत नाही
• हे headless CI मध्ये देखील चालवता येते, किंवा रिमोटवर लिस्नर उघडून स्थानिक TUI कनेक्ट करू शकता

थोडक्यात: हे "तुम्ही कोड लिहिणाऱ्या कामगाराचे व्यवस्थापन करत आहात" असे आहे, "तुम्ही स्क्रिप्टच्या वेडेपणावर लक्ष ठेवत आहात" असे नाही.

कसे स्थापित करावे

राल्फ-tui हे Bun/TypeScript इकोसिस्टमवर आधारित आहे, त्यामुळे ते स्थापित करणे सोपे आहे. अधिकृत इंस्टॉलेशन पेज देखील दिलेले आहे.

प्रथम तुमच्या मशीनवर बन (bun) आहे का ते तपासा:

bun --version नंतर राल्फ-tui स्थापित करा (मी येथे एक सामान्य इंस्टॉलेशन पद्धत देत आहे, अधिक माहितीसाठी अधिकृत इंस्टॉलेशन पेज पहा):

bun add -g ralph-tui इंस्टॉलेशन पूर्ण झाल्यावर तपासा:

ralph-tui --help जर तुम्ही Node वापरत असाल आणि बन वापरू इच्छित नसाल, तर तेही चालेल:

npm i -g ralph-tui

मोठी गोष्ट करण्यापूर्वी, एक लहान लूप चालवा

मी शिफारस करतो की पहिल्या वापरामध्ये, "संपूर्ण repo रीस्ट्रक्चर" करण्याचा प्रयत्न करू नका. फक्त एक गोष्ट करा: एक स्वीकार्य लहान कार्य पूर्ण करा.

इनिशियलायझेशन

कोणतीही डिरेक्टरी उघडा:

mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setup हे इंटरॅक्टिव्ह विझार्ड प्रक्रियेत प्रवेश करेल, सोप्या भाषेत सांगायचे तर "राल्फ-tui तुमच्या repo मध्ये स्थापित करेल", ते खालील गोष्टी करेल:

• तुमच्या मशीनवर कोणते एजंट्स स्थापित आहेत ते स्वयंचलितपणे शोधा (उदाहरणार्थ, Claude Code, OpenCode इ.)
• प्रोजेक्टमध्ये एक कॉन्फिगरेशन फाइल तयार करा: .ralph-tui/config.toml
• PRD निर्मिती/कार्य रूपांतरण संबंधित स्किल्स स्थापित करा (तुम्हाला स्वतःहून करण्याची गरज नाही)

माझा वैयक्तिक सल्लाः पहिल्यांदा आळस करू नका, setup एकदा तरी चालवा.

प्रोजेक्ट PRD तयार करा

Setup पूर्ण झाल्यावर, पुढचा टप्पा म्हणजे अधिकृत ट्यूटोरियलमधील सर्वात महत्त्वाचा भाग, जो डेमो म्हणून लिहिण्यासाठी योग्य आहे: create-prd.

ralph-tui create-prd --chat ही कमांड एक संवादात्मक प्रक्रिया सुरू करेल, जी एका प्रॉडक्ट मॅनेजरप्रमाणे तुमच्याकडून आवश्यक उद्दिष्ट्ये, मर्यादा आणि स्वीकृती मानके विचारेल. प्रश्न विचारल्यानंतर, ते प्रोजेक्टमध्ये दोन गोष्टी तयार करेल (हे महत्त्वाचे आहे):

• PRD ची markdown फाइल: ./tasks/prd-feature.md
• थेट अंमलबजावणीयोग्य कार्य फाइल: ./prd.json

या टप्प्यावर, तुम्ही Ralph-TUI च्या "standard closed loop" मध्ये प्रवेश करता:

आवश्यकता (PRD) → कार्य (prd.json) → अंमलबजावणी (run)

Run करा

prd.json मिळाल्यानंतर, run करणे स्वाभाविक आहे:

ralph-tui run --prd ./prd.json तुम्हाला TUI सुरू झालेले दिसेल, आणि ते loop मध्ये चालेल: कार्य निवडा → अंमलबजावणी करा → पूर्ण झाले की नाही ते तपासा → स्थिती लिहा → समाप्त करा किंवा पुढील फेरी.

पहिल्यांदा चालवताना, मी Iteration Limit जोडण्याचा सल्ला देतो, प्रथम त्याला पिंजऱ्यात बंद करा:

ralph-tui run --prd ./prd.json --iterations 5 चालवल्यानंतर बदल तपासा, चाचणी करा आणि PRD आणि कार्य अपेक्षेप्रमाणे आहेत की नाही ते पहा. ही साखळी योग्य आहे याची खात्री करा, नंतर Iterations उघडा आणि headless/remote वर जा, हे अधिक विश्वसनीय आहे.

यावेळी तुम्ही हे निश्चित करू शकता: हे loop खरोखर सुरू झाले आहे.

मॉडेल/एजंट कसे निवडायचे? पैसे वाचवण्याबद्दल सत्य काय आहे ते सांगा

मला माहित आहे की बर्‍याच लोकांना याची काळजी आहे: "मी Claude Code वापरणे टाळू शकतो का? मी स्वस्त मॉडेल वापरू शकतो का?"

उत्तर आहे: होय.

Ralph-TUI तुम्हाला एजंट आणि मॉडेल निर्दिष्ट करण्यास समर्थन देते (अधिकृत Run डॉक्युमेंटमध्ये उदाहरणे आहेत).

उदाहरणार्थ, Claude Opus वापरा:

ralph-tui run --prd ./prd.json --agent claude --model opus पण प्रामाणिकपणे, मी स्वतः "चाचणी पूर्ण करणे, Lint दुरुस्त करणे" यासाठी Opus वापरणार नाही, ते खूप महाग आहे. माझी सवय स्तरानुसार विभागणी करण्याची आहे:

• स्वस्त मॉडेल: मोठ्या प्रमाणात पुनरावृत्ती होणारी कामे करा (चाचणी पूर्ण करणे, भाष्ये जोडणे, स्वरूपण दुरुस्त करणे, सीमा जोडणे)
• महाग मॉडेल: फक्त महत्त्वाच्या ठिकाणी वापरा (आर्किटेक्चर बदल, कठीण बग, मुख्य तर्कशास्त्र)

जर तुम्ही सामान्य डेव्हलपर असाल, तर ही विचारसरणी अधिक महत्त्वाची आहे. कारण तुमच्याकडे मोठ्या कंपनीचे बजेट नाही, तुम्हाला खर्च नियंत्रणात ठेवावा लागेल, तरच तुम्ही ते जास्त काळ चालवू शकता.

आणखी चांगले हवे आहे? "PRD लिहिण्याचे" काम एजंटला द्या

Ralph-TUI मध्ये मला आवडणारी एक गोष्ट आहे: ते स्किल्सला सपोर्ट करते (सोप्या भाषेत एजंटसाठी बाह्य कमांड्स).

अधिकृतपणे इन्स्टॉल करण्याची पद्धत add-skill वापरणे आहे:

bunx add-skill subsy/ralph-tui --all किंवा निर्दिष्ट एजंटवर स्थापित करा, उदाहरणार्थ claude-code:

bunx add-skill subsy/ralph-tui -a claude-code -g -y इन्स्टॉल केल्यानंतर, तुम्ही एजंट सेशनमध्ये स्लॅश कमांड वापरू शकता:

/ralph-tui-prd /ralph-tui-create-json /ralph-tui-create-beads हे IDE मध्ये प्लगइन स्थापित करण्यासारखे आहे, फक्त हे प्लगइन एजंटसाठी आहे. याचा अर्थ "माणसाने गरजेनुसार माहिती देण्याचा" वेळ कमी करणे, आणि गरज → कार्य → अंमलबजावणी एका ओळीत करणे.

हे कधी वापरावे? आणि कधी वापरू नये?मला 'AI वापरून सर्व काही करता येते' अशा प्रकारची मांडणी फारशी आवडत नाही, कारण ती दिशाभूल करणारी ठरू शकते. Tool हे Tool च आहे, ते योग्य परिस्थितीतच उपयुक्त ठरते.

ralph-tui वापरण्यासाठी योग्य परिस्थिती

तुमच्याकडे खालील प्रकारची कामे असल्यास:

• Test Cases जोडणे (विशेषतः जुन्या प्रोजेक्ट्ससाठी)
• Lint / Format मधील त्रुटी सुधारणे
• लहान प्रमाणात Refactoring करणे (Duplicate Code कमी करणे)
• Batch मध्ये Types जोडणे, Boundary Conditions तपासणे
• Requirement Decomposition नंतर Task Queue नुसार हळू हळू पुढे ढकलणे

या कामांमध्ये एक गोष्ट Ort आहे: जास्त Tasks, उच्च पुनरावृत्ती, Acceptable आणि Iterative Improvement शक्य.

ralph-tui वापरण्यासाठी अयोग्य परिस्थिती

तुम्ही खालील कामे करत असल्यास:

• मोठे Refactoring, ज्यामध्ये Acceptable Standard स्पष्ट नाहीत
• Requirement स्वतःच अस्पष्ट आहे, तुमच्या डोक्यात असलेल्या ज्ञानावर अवलंबून आहे
• Team Members मध्ये जास्त Communication / Confirmation ची आवश्यकता आहे
• Product Decisions घेण्याची गरज आहे

अशा परिस्थितीत, Agent Loop गोंधळ वाढवू शकतो.

ralph-loop (ralph-claude-code) आणि यात काय फरक आहे?

ralph-claude-code हे 'Claude Code साठी Autopilot Mode' सारखे आहे: Script ते सुरू करते, Loop चालवते, Exit Detection, Rate Limiting आणि Circuit Breaker सारख्या गोष्टींची काळजी घेते. तुम्हाला 'जलद' Result हवा असल्यास, ते खूप जलद आहे.

ralph-tui हे 'Agent Loop साठी Engineering Control Panel' सारखे आहे: ते विशिष्ट Model किंवा Task System ला बांधलेले नाही. ते 'दीर्घकाळ चालवणे, निरीक्षण करणे, नियंत्रित करणे, Recover करणे आणि Remote Access' यांसारख्या Engineering समस्यांचे निराकरण करण्याचा प्रयत्न करते.

म्हणून तुम्ही मला विचाराल की काय निवडायचे?

• तुम्ही Claude Code User असाल आणि तुम्हाला ते लवकर सुरू करायचे असेल → ralph-claude-code
• तुम्हाला वेगवेगळे Models वापरायचे असतील, पैसे वाचवायचे असतील आणि Loop ला Service म्हणून Manage करायचे असेल → ralph-tui

शेवटी: तुमच्या Repository ला Laboratory बनवू नका

Agent Loop चालवताना मी स्वतः काही नियम पाळतो, ते खालीलप्रमाणे आहेत, त्यांचे पालन केल्यास अयशस्वी होण्याची शक्यता कमी होईल:

• Branch मध्ये चालवा, Main Branch वर प्रयोग करू नका.
• पहिल्यांदा चालवताना --iterations नक्की Add करा, जेणेकरून ते वेडे वागत नाही याची खात्री करा.
• Task Acceptable असली पाहिजे: Test Run करता आली पाहिजे, Lint Run करता आले पाहिजे किंवा Output Files Compare करता आले पाहिजे.
• थांबायला शिका: Loop मध्ये अडकल्यास, पुढे पैसे खर्च करण्यापेक्षा थांबणे अधिक चांगले आहे.
• स्वस्त Models चा वापर Rough Work साठी करा आणि महाग Models चा वापर Critical Work साठी करा: Cost Optimization हे Operation मधून येते, प्रार्थनेतून नाही.प्रकल्प पत्ताः https://github.com/subsy/ralph-tui