તમે જેની રાહ જોઈ રહ્યા હતા તે આખરે આવી ગયું! રાલ્ફ TUI, વિઝ્યુઅલાઈઝ્ડ રાલ્ફ લૂપ

મેં અગાઉ ralph-loop પર એક ટ્યુટોરીયલ લખ્યું હતું, અને ઘણા મિત્રોએ તેને ચલાવ્યા પછી સમાન પ્રતિસાદ આપ્યો: મજા આવી, ક્લાઉડ કોડ આખરે લાંબા સમય સુધી ચાલી શકે છે. પરંતુ કેટલીકવાર તમે જુઓ છો કે તે સ્થિર લાગે છે, અને તમે મદદ કરી શકતા નથી પરંતુ આશ્ચર્ય પામો છો: "શું તે આગળ વધી રહ્યું છે, કે તે ફક્ત વર્તુળોમાં જઈ રહ્યું છે?"

આ જ કારણ છે કે મેં તાજેતરમાં ralph-tui સાથે ગડબડ કરી.

ralph-tui ક્લાઉડ કોડને ફરજિયાતપણે બાંધતું નથી, તે રાલ્ફ લૂપના સારને વારસામાં મેળવે છે અને વિકસાવે છે, અને કાર્ય અમલીકરણ અને પ્રક્રિયાને વિઝ્યુઅલાઈઝ કરે છે, જે મોટા મોડેલોને લાંબા સમય સુધી કામ કરવાનું ખૂબ જ સરળ બનાવે છે. તમે અન્ય એજન્ટો અને અન્ય મોડેલોને સંપૂર્ણપણે કનેક્ટ કરી શકો છો, સ્થાનિક રાશિઓ, સસ્તા રાશિઓ, જે તમે લાંબા સમય સુધી ચલાવી શકો છો. ralph-tui સાથે, આપણા સામાન્ય લોકો માટે, તે મેન્યુઅલથી ઓટોમેટિકમાં બદલવા અને ક્રૂઝ કંટ્રોલ રાખવા જેટલું જ મહત્વપૂર્ણ છે.

તે બરાબર શું છે?

તમે ralph-tui ને "AI કોડિંગ એજન્ટનું લૂપ ઓર્કેસ્ટ્રેટર" તરીકે વિચારી શકો છો, પરંતુ તે ફક્ત "ચલાવવા" થી સંતુષ્ટ નથી, તે "તમે જોઈ શકો છો, નિયંત્રિત કરી શકો છો અને પુનઃસ્થાપિત કરી શકો છો" તેની વધુ કાળજી લે છે.

તેની મૂળભૂત કાર્ય કરવાની રીત ખૂબ જ સરળ છે:

• તમે તેને કાર્યોનો સમૂહ આપો (PRD થી અથવા અન્ય કાર્ય સિસ્ટમથી)
• તે સૌથી વધુ પ્રાથમિકતાવાળા એકને પસંદ કરે છે
• પ્રોમ્પ્ટ ભેગા કરો
• એજન્ટને ચલાવવા માટે ખેંચો
• નક્કી કરો કે આ કાર્ય પૂર્ણ થયું છે કે નહીં
• સ્થિતિ લખો
• આગલો રાઉન્ડ ચાલુ રાખો

મુખ્ય મુદ્દો એ છે કે: તમે આ બધું ટર્મિનલમાં જોઈ શકો છો, અને તમે કોઈપણ સમયે રોકી શકો છો અને કબજો કરી શકો છો. તેના અધિકારીઓએ પણ તેની સ્થિતિ ખૂબ જ સ્પષ્ટ રીતે લખી છે: એક ઇન્ટરેક્ટિવ TUI સાથેનું એજન્ટ લૂપ ઓર્કેસ્ટ્રેટર, અને TUI / હેડલેસ / રિમોટને સપોર્ટ કરે છે.

હું શા માટે કહું છું કે તે "લાંબા સમય સુધી ચલાવવા" માટે વધુ યોગ્ય છે?

લૂપ ચલાવવાની સ્ક્રિપ્ટ સાથેની સૌથી મોટી સમસ્યા એ નથી કે તે ચાલી શકતી નથી, પરંતુ તમને ખબર નથી કે તે ક્યાં સુધી ચાલી છે.

તમે જુઓ છો કે લોગ ઝડપથી અપડેટ થઈ રહ્યા છે, અને પંખો પણ ખુશીથી ફરી રહ્યો છે, પરંતુ તમને ખાતરી નથી:

• શું તે સમાન બગને વારંવાર ઠીક કરી રહ્યું છે?
• શું તે સતત કોડના સમાન ભાગને બદલી રહ્યું છે અને પછી તેને પાછું બદલી રહ્યું છે?
• શું તે પૂર્ણ થઈ ગયું છે, પરંતુ બહાર નીકળ્યું નથી?
• શું તે કોઈ ચોક્કસ પરીક્ષણમાં અટવાઈ ગયું છે અને અનંત લૂપમાં છે?

ralph-tui નો ઉકેલ ખૂબ જ "એન્જિનિયરિંગ" છે:

• સત્ર ખ્યાલ છે, અને સ્થિતિ ડિસ્ક પર સાચવવામાં આવશે (.ralph-tui/session.json)
• જો તે ક્રેશ થાય તો તે ફરીથી ચલાવી શકાય છે (ક્રેશ રિકવરી)
• લોક મિકેનિઝમ છે, તમારા દ્વારા ખોલવામાં આવેલા બહુવિધ ઉદાહરણોને ડિરેક્ટરીને ગડબડ કરતા અટકાવવા માટે
• તે હેડલેસને CI પર પણ ફેંકી શકે છે, અને દૂરથી રિમોટ લિસનર પણ ખોલી શકે છે, અને સ્થાનિક TUI તેની સાથે કનેક્ટ થઈ શકે છે

એક શબ્દમાં: તે વધુ "તમે કોડ લખી શકે તેવા કામદારનું સંચાલન કરી રહ્યા છો" જેવું છે, તેના બદલે "તમે સ્ક્રિપ્ટને ગાંડપણમાં જોતા હોવ" તેના કરતા.

કેવી રીતે ઇન્સ્ટોલ કરવું

ralph-tui નો આ સેટ Bun/TypeScript ઇકોસિસ્ટમ છે, તેથી તેને ઇન્સ્ટોલ કરવું ખૂબ જ સરળ છે. અધિકારીઓએ ઇન્સ્ટોલેશન પૃષ્ઠ પણ આપ્યું છે.

પ્રથમ ખાતરી કરો કે તમારી મશીન પર બન છે:

bun --version પછી ralph-tui ઇન્સ્ટોલ કરો (હું અહીં એક લાક્ષણિક ઇન્સ્ટોલેશન પદ્ધતિ આપીશ, વિગતો માટે સત્તાવાર ઇન્સ્ટોલેશન પૃષ્ઠનો સંદર્ભ લો):

bun add -g ralph-tui ઇન્સ્ટોલેશન પછી તપાસો:

ralph-tui --help જો તમે Node પાર્ટી છો અને બનને સ્પર્શ કરવા માંગતા નથી, તો તે પણ ઠીક છે:

npm i -g ralph-tui

મોટી વસ્તુઓ કરતા પહેલા, એક નાનું બંધ લૂપ ચલાવો

હું ભલામણ કરું છું કે પ્રથમ વખત ઉપયોગ કરતી વખતે, તરત જ "સમગ્ર રેપોને ફરીથી બનાવવું" જેવું કંઈક ન કરો. તમે ફક્ત એક જ વસ્તુ કરો: તેને સ્વીકાર્ય નાના કાર્ય દ્વારા ચલાવો.

પ્રારંભિકરણ

કોઈપણ ડિરેક્ટરી ખોલો:

mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setup આ એક ઇન્ટરેક્ટિવ વિઝાર્ડ પ્રક્રિયામાં પ્રવેશ કરશે, જેનો અર્થ છે "તમારા આ રિપોઝીટરીમાં ralph-tui ઇન્સ્ટોલ કરો", તે કરશે:- તમારા મશીન પર કયા એજન્ટ્સ ઇન્સ્ટોલ કરેલા છે તે આપમેળે શોધી કાઢે છે (જેમ કે ક્લોડ કોડ, ઓપનકોડ વગેરે)

• પ્રોજેક્ટમાં રૂપરેખાંકન ફાઇલ જનરેટ કરે છે: .ralph-tui/config.toml
• PRD જનરેટ કરવા/ટાસ્ક કન્વર્ટ કરવા સંબંધિત સ્કિલ્સ ઇન્સ્ટોલ કરે છે (પાછળથી તમારે જાતે જ મેન્યુઅલી સેટઅપ કરવાની જરૂર નહીં પડે)

મારો વ્યક્તિગત અભિપ્રાય: પ્રથમ વખત આળસ ન કરો, setup એકવાર જરૂરથી ચલાવો.

પ્રોજેક્ટ PRD જનરેટ કરો

setup ચલાવ્યા પછી, આગળનું પગલું એ સત્તાવાર ટ્યુટોરીયલમાં સૌથી મહત્વપૂર્ણ છે, અને તે જનસંપર્ક ડેમો તરીકે લખવા માટે સૌથી યોગ્ય છે: create-prd.

ralph-tui create-prd --chat આ આદેશ એક સંવાદાત્મક પ્રક્રિયામાં પ્રવેશ કરશે, તે એક પ્રોડક્ટ મેનેજરની જેમ તમારી પાસેથી જરૂરિયાતો, લક્ષ્યો, સીમા શરતો અને સ્વીકૃતિ માપદંડો વિશે પૂછપરછ કરશે. પૂછપરછ કર્યા પછી, તે પ્રોજેક્ટમાં સીધી બે વસ્તુઓ આઉટપુટ કરશે (આ મહત્વપૂર્ણ છે):

• PRD ની માર્કડાઉન ફાઇલ: ./tasks/prd-feature.md
• સીધી એક્ઝિક્યુટેબલ ટાસ્ક ફાઇલ: ./prd.json

આ પગલા પર, તમે ખરેખર ralph-tui ના "સ્ટાન્ડર્ડ ક્લોઝ્ડ લૂપ" માં પ્રવેશ કરો છો:

જરૂરિયાત (PRD) → ટાસ્ક (prd.json) → એક્ઝિક્યુશન (run)

run કરો

prd.json સાથે, run કરવું સ્વાભાવિક છે:

ralph-tui run --prd ./prd.json તમે TUI ને શરૂ થતું જોશો, અને તે લૂપ શરૂ કરશે: ટાસ્ક પસંદ કરો → એક્ઝિક્યુટ કરો → પૂર્ણ થયેલ છે કે નહીં તે નક્કી કરો → સ્ટેટસ લખો → સમાપ્ત કરો અથવા આગલો રાઉન્ડ.

જ્યારે તમે પહેલીવાર ચલાવો છો, ત્યારે હું ભારપૂર્વક ભલામણ કરું છું કે તમે પુનરાવર્તનની મર્યાદા ઉમેરો, પહેલા તેને પાંજરામાં બંધ કરો:

ralph-tui run --prd ./prd.json --iterations 5 ચલાવ્યા પછી, તમે ફેરફારો જુઓ, પરીક્ષણ ચલાવો, અને જુઓ કે PRD અને ટાસ્ક અપેક્ષા મુજબ છે કે નહીં. ખાતરી કરો કે આ લિંક કાર્યરત છે, પછી પુનરાવર્તનોને ખોલો, અને પછી હેડલેસ/રિમોટ પર જાઓ, આ એક વિશ્વસનીય રીત છે.

આ સમયે, તમે મૂળભૂત રીતે ખાતરી કરી શકો છો: આ લૂપ ખરેખર ચાલી રહી છે.

મોડેલ/એજન્ટ કેવી રીતે પસંદ કરવું? પૈસા બચાવવાની વાતમાં પ્રમાણિકતા જરૂરી છે

હું જાણું છું કે ઘણા લોકો સૌથી વધુ ચિંતિત છે: "શું હું ક્લોડ કોડનો ઉપયોગ કર્યા વિના કરી શકું? શું હું સસ્તા મોડેલનો ઉપયોગ કરી શકું?"

જવાબ છે: હા.

ralph-tui તમને એજન્ટ અને મોડેલ સ્પષ્ટ કરવાની મંજૂરી આપે છે (સત્તાવાર run દસ્તાવેજમાં ઉદાહરણો છે).

ઉદાહરણ તરીકે, ક્લોડ ઓપસનો ઉપયોગ કરો:

ralph-tui run --prd ./prd.json --agent claude --model 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 દ્વારા થઈ શકે છે", તે લોકોને ગેરમાર્ગે દોરનારી છે. સાધન એ સાધન છે, તે યોગ્ય પરિસ્થિતિમાં જ મૂલ્યવાન છે.

ralph-tui નો ઉપયોગ કરવા માટે યોગ્ય દૃશ્યો

તમારી પાસે આ પ્રકારના કામોનો ઢગલો છે:

• પરીક્ષણ ઉમેરવું (ખાસ કરીને જૂના પ્રોજેક્ટ્સમાં)
• lint / format ને ઠીક કરવું
• નાના પગલાંમાં રિફેક્ટરિંગ (પુનરાવર્તિત કોડને એકત્રિત કરવો)
• બેચમાં પ્રકારો ઉમેરવા, સીમાઓ ભરવી
• જરૂરિયાતોને તોડીને કાર્ય કતાર દ્વારા ધીમે ધીમે આગળ વધવું

આ પ્રકારના કામમાં એક સામાન્ય બાબત છે: કાર્યો ઘણા છે, પુનરાવર્તન ઊંચું છે, સ્વીકાર્ય છે, પુનરાવર્તિત રીતે આગળ વધી શકાય છે.

ralph-tui ને બળજબરીથી ઉપયોગ કરવા માટે યોગ્ય ન હોય તેવા દૃશ્યો

તમે આ પ્રકારનું કામ કરી રહ્યા છો:

• એક વખતનું મોટું રિફેક્ટરિંગ, સ્વીકૃતિ ધોરણો અસ્પષ્ટ છે
• જરૂરિયાતો પોતે જ અસ્પષ્ટ છે, તમારા મગજમાં રહેલા ગર્ભિત જ્ઞાન પર આધાર રાખે છે
• મોટી સંખ્યામાં ક્રોસ-ટીમ સંચાર / પુષ્ટિની જરૂર છે
• તમારે ઉત્પાદનનો નિર્ણય લેવાની જરૂર છે

આવા કાર્યોમાં, agent loop માત્ર મૂંઝવણને વધારે છે.

તે ralph-loop (ralph-claude-code) થી કેવી રીતે અલગ છે?

ralph-claude-code એ "Claude Code ના ઓટોપાયલોટ પ્લગ-ઇન" જેવું છે: સ્ક્રિપ્ટ તેને શરૂ કરે છે, લૂપ ચલાવે છે, બહાર નીકળવાની તપાસ, દર મર્યાદા, સર્કિટ બ્રેકર બધું જ તમારા માટે આવરી લે છે. તમને "ઝડપ" જોઈએ છે, તે ખૂબ જ ઝડપી છે.

ralph-tui એ "agent loop ના એન્જિનિયરિંગ કન્સોલ" જેવું છે: તે કોઈ ચોક્કસ મોડેલને સોલ્ડર કરતું નથી, કે કોઈ ચોક્કસ કાર્ય સિસ્ટમને સોલ્ડર કરતું નથી. તે "લાંબા ગાળાના રન, અવલોકનક્ષમ, નિયંત્રણક્ષમ, પુનઃપ્રાપ્ત કરી શકાય તેવું, દૂરથી નિયંત્રિત કરી શકાય તેવું" જેવી એન્જિનિયરિંગ સમસ્યાઓ ઉકેલવા માંગે છે.

તો તમે મને પૂછો કે કેવી રીતે પસંદ કરવું?

• તમે Claude Code ના વપરાશકર્તા છો, અને તેને ઝડપથી ચલાવવા માંગો છો → ralph-claude-code
• તમે અલગ મોડેલોને કનેક્ટ કરવા માંગો છો, પૈસા બચાવવા માંગો છો, લૂપને સેવા તરીકે મેનેજ કરવા માંગો છો → ralph-tui

છેલ્લે: તેને તમારી રિપોઝીટરીને પ્રયોગશાળા ન બનાવવા દો

હું પોતે agent loop ચલાવવા માટે કેટલાક કડક નિયમો ધરાવું છું, અહીં લખું છું, તમે તેનું પાલન કરશો તો નિષ્ફળ જવાની શક્યતા ઘણી ઓછી થઈ જશે:

• શાખામાં ચલાવો, main પર જોરશોરથી કામ ન કરો.
• પહેલીવાર ચલાવો ત્યારે --iterations ચોક્કસ ઉમેરો, પહેલા નાના પગલાંમાં ખાતરી કરો કે તે પાગલ નથી થઈ રહ્યું.
• કાર્ય સ્વીકાર્ય હોવું જોઈએ: કાં તો તે પરીક્ષણ ચલાવી શકે, કાં તો તે lint ચલાવી શકે, કાં તો તે આઉટપુટ ફાઇલોની તુલના કરી શકે.
• તમારે રોકવાનું શીખવું જોઈએ: જ્યારે તમે જુઓ કે તે વર્તુળોમાં ફરવાનું શરૂ કરે છે, ત્યારે પૈસા બાળવા કરતાં થોભાવવું વધુ સમજદારીભર્યું છે.
• સસ્તા મોડેલો દ્વારા સામાન્ય કામ કરાવો, મોંઘા મોડેલો દ્વારા મહત્વપૂર્ણ કામ કરાવો: ખર્ચ સંચાલન દ્વારા આવે છે, પ્રાર્થના દ્વારા નહીં.પ્રોજેક્ટ સરનામું: https://github.com/subsy/ralph-tui