ਤੁਹਾਡੇ ਲਈ ਆਖਰਕਾਰ ਆ ਗਿਆ! ਰਾਲਫ਼ ਟੀਯੂਆਈ, ਵਿਜ਼ੂਅਲਾਈਜ਼ਡ ਰਾਲਫ਼ ਲੂਪ

ਮੈਂ ਪਹਿਲਾਂ 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 ਜਨਰੇਸ਼ਨ/ਟਾਸਕ ਪਰਿਵਰਤਨ ਨਾਲ ਸਬੰਧਤ ਹੁਨਰਾਂ ਨੂੰ ਵੀ ਇੰਸਟਾਲ ਕਰਦਾ ਹੈ (ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਖੁਦ ਹੱਥੀਂ ਨਾ ਕਰਨਾ ਪਵੇ)।

ਮੇਰੀ ਨਿੱਜੀ ਸਲਾਹ: ਪਹਿਲੀ ਵਾਰ ਆਲਸ ਨਾ ਕਰੋ, ਸੈੱਟਅੱਪ ਨੂੰ ਇੱਕ ਵਾਰ ਜ਼ਰੂਰ ਚਲਾਓ।

ਪ੍ਰੋਜੈਕਟ PRD ਤਿਆਰ ਕਰੋ

ਸੈੱਟਅੱਪ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਅਗਲਾ ਕਦਮ ਅਧਿਕਾਰਤ ਟਿਊਟੋਰੀਅਲ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਅਜਿਹਾ ਹਿੱਸਾ ਹੈ ਜਿਸਨੂੰ ਇੱਕ ਜਨਤਕ ਖਾਤੇ ਦੇ ਡੈਮੋ ਵਜੋਂ ਲਿਖਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ: create-prd।

ralph-tui create-prd --chat ਇਹ ਕਮਾਂਡ ਇੱਕ ਗੱਲਬਾਤ ਵਾਲੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦਾਖਲ ਹੋਵੇਗੀ, ਜੋ ਇੱਕ ਉਤਪਾਦ ਮੈਨੇਜਰ ਵਾਂਗ ਤੁਹਾਡੇ ਤੋਂ ਮੰਗਾਂ, ਟੀਚਿਆਂ, ਸੀਮਾਵਾਂ ਅਤੇ ਸਵੀਕ੍ਰਿਤੀ ਮਾਪਦੰਡਾਂ ਬਾਰੇ ਪੁੱਛੇਗੀ। ਪੁੱਛਣ ਤੋਂ ਬਾਅਦ, ਇਹ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਦੋ ਚੀਜ਼ਾਂ ਛਾਪੇਗਾ (ਇਹ ਮੁੱਖ ਗੱਲ ਹੈ):

• ਇੱਕ PRD ਦੀ ਮਾਰਕਡਾਊਨ ਫਾਈਲ: ./tasks/prd-feature.md
• ਇੱਕ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਚਲਾਉਣ ਯੋਗ ਟਾਸਕ ਫਾਈਲ: ./prd.json

ਇਸ ਕਦਮ 'ਤੇ, ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਰਾਲਫ-ਟੀਯੂਆਈ (ralph-tui) ਦੇ "ਸਟੈਂਡਰਡ ਬੰਦ ਲੂਪ" ਵਿੱਚ ਦਾਖਲ ਹੋ ਜਾਂਦੇ ਹੋ:

ਮੰਗ (PRD) → ਟਾਸਕ (prd.json) → ਚਲਾਓ (run)

ਚਲਾਓ (run)

prd.json ਹੋਣ ਤੋਂ ਬਾਅਦ, ਇਸਨੂੰ ਚਲਾਉਣਾ ਸੁਭਾਵਿਕ ਹੈ:

ralph-tui run --prd ./prd.json ਤੁਸੀਂ TUI ਨੂੰ ਉੱਪਰ ਆਉਂਦੇ ਹੋਏ ਦੇਖੋਗੇ, ਅਤੇ ਇਹ ਲੂਪ ਸ਼ੁਰੂ ਕਰੇਗਾ: ਟਾਸਕ ਚੁਣੋ → ਚਲਾਓ → ਪੂਰਾ ਹੋਣ ਦਾ ਨਿਰਣਾ ਕਰੋ → ਸਥਿਤੀ ਲਿਖੋ → ਖਤਮ ਕਰੋ ਜਾਂ ਅਗਲਾ ਗੇੜ।

ਪਹਿਲੀ ਵਾਰ ਚਲਾਉਣ 'ਤੇ, ਮੈਂ ਜ਼ੋਰਦਾਰ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਇਟਰੇਸ਼ਨ ਸੀਮਾ ਸ਼ਾਮਲ ਕਰੋ, ਪਹਿਲਾਂ ਇਸਨੂੰ ਪਿੰਜਰੇ ਵਿੱਚ ਬੰਦ ਕਰੋ:

ralph-tui run --prd ./prd.json --iterations 5 ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਬਦਲਾਵਾਂ ਨੂੰ ਦੇਖੋ, ਟੈਸਟ ਚਲਾਓ, ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ PRD ਅਤੇ ਟਾਸਕ ਉਮੀਦਾਂ 'ਤੇ ਖਰੇ ਉਤਰਦੇ ਹਨ। ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿ ਇਹ ਲਿੰਕ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਟਰੇਸ਼ਨਾਂ ਨੂੰ ਜਾਰੀ ਕਰੋ, ਫਿਰ ਹੈੱਡਲੈੱਸ/ਰਿਮੋਟ 'ਤੇ ਜਾਓ, ਇਹ ਇੱਕ ਭਰੋਸੇਯੋਗ ਰਫ਼ਤਾਰ ਹੈ।

ਇਸ ਸਮੇਂ, ਤੁਸੀਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹੋ: ਇਹ ਲੂਪ ਅਸਲ ਵਿੱਚ ਚੱਲ ਰਿਹਾ ਹੈ।

ਮਾਡਲ/ਏਜੰਟ ਕਿਵੇਂ ਚੁਣਨਾ ਹੈ? ਪੈਸੇ ਬਚਾਉਣ ਬਾਰੇ ਸੱਚਾਈ ਦੱਸਣੀ ਪਵੇਗੀ

ਮੈਨੂੰ ਪਤਾ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਸਭ ਤੋਂ ਵੱਧ ਇਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਕਰਦੇ ਹਨ: "ਕੀ ਮੈਂ ਕਲਾਉਡ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਕਰ ਸਕਦਾ ਹਾਂ? ਕੀ ਮੈਂ ਸਸਤੇ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?"

ਜਵਾਬ ਹੈ: ਹਾਂ।

ralph-tui ਤੁਹਾਨੂੰ ਏਜੰਟ ਅਤੇ ਮਾਡਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (ਅਧਿਕਾਰਤ ਰਨ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਉਦਾਹਰਣਾਂ ਹਨ)।

ਉਦਾਹਰਨ ਲਈ, ਕਲਾਉਡ ਓਪਸ ਦੀ ਵਰਤੋਂ ਕਰੋ:

ralph-tui run --prd ./prd.json --agent claude --model opus ਪਰ ਇਮਾਨਦਾਰੀ ਨਾਲ, ਮੈਂ ਖੁਦ "ਟੈਸਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ, ਲਿੰਟ ਨੂੰ ਠੀਕ ਕਰਨ" ਵਰਗੇ ਕੰਮ ਕਰਨ ਲਈ ਓਪਸ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਾਂਗਾ, ਇਹ ਬਹੁਤ ਮਹਿੰਗਾ ਹੈ। ਮੇਰੀ ਆਦਤ ਲੇਅਰਿੰਗ ਕਰਨ ਦੀ ਹੈ:

• ਸਸਤੇ ਮਾਡਲ: ਬਹੁਤ ਸਾਰੇ ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੰਮ ਚਲਾਓ (ਟੈਸਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰੋ, ਟਿੱਪਣੀਆਂ ਨੂੰ ਪੂਰਾ ਕਰੋ, ਫਾਰਮੈਟ ਠੀਕ ਕਰੋ, ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਕਰੋ)
• ਮਹਿੰਗੇ ਮਾਡਲ: ਸਿਰਫ਼ ਮੁੱਖ ਨੋਡਾਂ 'ਤੇ ਦਿਖਾਈ ਦਿਓ (ਢਾਂਚੇ ਦੀ ਵਿਵਸਥਾ, ਮੁਸ਼ਕਲ ਬੱਗ, ਮੁੱਖ ਤਰਕ)

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਆਮ ਡਿਵੈਲਪਰ ਹੋ, ਤਾਂ ਇਹ ਸੋਚ ਹੋਰ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਕਿਉਂਕਿ ਤੁਹਾਡੇ ਕੋਲ ਵੱਡੀ ਕੰਪਨੀ ਦਾ ਬਜਟ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਲਾਗਤ ਨੂੰ ਕਾਬੂ ਵਿੱਚ ਰੱਖਣਾ ਹੋਵੇਗਾ ਤਾਂ ਜੋ ਤੁਸੀਂ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲ ਸਕੋ।

ਹੋਰ ਵੀ ਵਧੀਆ ਚਾਹੁੰਦੇ ਹੋ? "PRD ਲਿਖਣ" ਦਾ ਕੰਮ ਵੀ ਏਜੰਟ ਨੂੰ ਸੌਂਪ ਦਿਓ

ralph-tui ਵਿੱਚ ਇੱਕ ਡਿਜ਼ਾਈਨ ਹੈ ਜੋ ਮੈਨੂੰ ਬਹੁਤ ਪਸੰਦ ਹੈ: ਇਹ ਹੁਨਰਾਂ (skills) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ (ਸਿੱਧੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਹ ਏਜੰਟ ਲਈ ਇੱਕ ਬਾਹਰੀ ਕਮਾਂਡ ਹੈ)।

ਅਧਿਕਾਰਤ ਇੰਸਟਾਲੇਸ਼ਨ ਵਿਧੀ 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 ਨੂੰ ਜ਼ਬਰਦਸਤੀ ਵਰਤਣ ਲਈ ਢੁਕਵੇਂ ਦ੍ਰਿਸ਼ ਨਹੀਂ ਹਨ

ਤੁਸੀਂ ਇਹ ਕਰ ਰਹੇ ਹੋ:

• ਇੱਕ ਵਾਰ ਦੀ ਵੱਡੀ ਰੀਫੈਕਟਰਿੰਗ, ਸਵੀਕ੍ਰਿਤੀ ਮਾਪਦੰਡ ਅਸਪਸ਼ਟ ਹਨ
• ਮੰਗਾਂ ਆਪਣੇ ਆਪ ਵਿੱਚ ਅਸਪਸ਼ਟ ਹਨ, ਤੁਹਾਡੇ ਦਿਮਾਗ ਵਿੱਚ ਲੁਕਵੇਂ ਗਿਆਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ
• ਬਹੁਤ ਸਾਰੇ ਕਰਾਸ-ਟੀਮ ਸੰਚਾਰ/ਪੁਸ਼ਟੀਕਰਨ ਦੀ ਲੋੜ ਹੈ
• ਤੁਹਾਨੂੰ ਉਤਪਾਦ ਦਾ ਨਿਰਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ

ਇਸ ਕਿਸਮ ਦਾ ਕੰਮ, ਏਜੰਟ ਲੂਪ ਸਿਰਫ਼ ਉਲਝਣ ਨੂੰ ਵਧਾਏਗਾ।

ralph-loop (ralph-claude-code) ਤੋਂ ਇਹ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ?

ralph-claude-code ਇੱਕ "Claude Code ਦੇ ਆਟੋਪਾਇਲਟ ਪਲੱਗ-ਇਨ" ਵਰਗਾ ਹੈ: ਸਕ੍ਰਿਪਟ ਇਸਨੂੰ ਖਿੱਚਦੀ ਹੈ, ਲੂਪ ਚਲਾਉਂਦੀ ਹੈ, ਅਤੇ ਐਗਜ਼ਿਟ ਡਿਟੈਕਸ਼ਨ, ਥ੍ਰੋਟਲਿੰਗ, ਅਤੇ ਸਰਕਟ ਬ੍ਰੇਕਰ ਤੁਹਾਡੇ ਲਈ ਸਭ ਕੁਝ ਕਵਰ ਕਰਦੇ ਹਨ। ਤੁਸੀਂ "ਤੇਜ਼" ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਇਹ ਤੇਜ਼ ਹੈ।

ralph-tui ਇੱਕ "ਏਜੰਟ ਲੂਪ ਇੰਜੀਨੀਅਰਿੰਗ ਕੰਸੋਲ" ਵਰਗਾ ਹੈ: ਇਹ ਕਿਸੇ ਖਾਸ ਮਾਡਲ ਜਾਂ ਕਿਸੇ ਖਾਸ ਟਾਸਕ ਸਿਸਟਮ ਨਾਲ ਨਹੀਂ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਇਹ "ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ, ਨਿਰੀਖਣਯੋਗ, ਨਿਯੰਤਰਣਯੋਗ, ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਯੋਗ, ਅਤੇ ਰਿਮੋਟ" ਵਰਗੀਆਂ ਇੰਜੀਨੀਅਰਿੰਗ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ।

ਤਾਂ ਤੁਸੀਂ ਮੈਨੂੰ ਪੁੱਛਦੇ ਹੋ ਕਿ ਕਿਵੇਂ ਚੁਣਨਾ ਹੈ?

• ਤੁਸੀਂ ਇੱਕ Claude Code ਉਪਭੋਗਤਾ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਜਲਦੀ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ → ralph-claude-code
• ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਮਾਡਲਾਂ ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਪੈਸੇ ਬਚਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਲੂਪ ਨੂੰ ਇੱਕ ਸੇਵਾ ਦੇ ਤੌਰ 'ਤੇ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ → ralph-tui

ਅੰਤ ਵਿੱਚ: ਇਸਨੂੰ ਆਪਣੀ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਇੱਕ ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਨਾ ਬਣਾਉਣ ਦਿਓ

ਮੈਂ ਖੁਦ ਏਜੰਟ ਲੂਪ ਚਲਾਉਣ ਲਈ ਕੁਝ ਸਖ਼ਤ ਨਿਯਮ ਹਨ, ਮੈਂ ਇੱਥੇ ਲਿਖ ਰਿਹਾ ਹਾਂ, ਤੁਸੀਂ ਇਸਦਾ ਪਾਲਣ ਕਰੋ, ਅਤੇ ਤੁਹਾਡੇ ਪਲਟਣ ਦੀ ਸੰਭਾਵਨਾ ਬਹੁਤ ਘੱਟ ਹੋਵੇਗੀ:

• ਇੱਕ ਬ੍ਰਾਂਚ ਵਿੱਚ ਚਲਾਓ, ਮੁੱਖ 'ਤੇ ਜਾਨਲੇਵਾ ਨਾ ਬਣੋ।
• ਪਹਿਲੀ ਵਾਰ ਚਲਾਉਣ ਵੇਲੇ --iterations ਨੂੰ ਜ਼ਰੂਰ ਜੋੜੋ, ਪਹਿਲਾਂ ਛੋਟੇ ਕਦਮਾਂ ਵਿੱਚ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਇਹ ਪਾਗਲ ਨਹੀਂ ਹੋਵੇਗਾ।
• ਕੰਮ ਸਵੀਕਾਰਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: ਜਾਂ ਤਾਂ ਇਹ ਟੈਸਟ ਚਲਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਇਹ ਲਿੰਟ ਚਲਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਇਹ ਆਉਟਪੁੱਟ ਫਾਈਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਦਾ ਹੈ।
• ਤੁਹਾਨੂੰ ਰੁਕਣਾ ਸਿੱਖਣਾ ਚਾਹੀਦਾ ਹੈ: ਇਹ ਦੇਖ ਕੇ ਕਿ ਇਹ ਚੱਕਰ ਕੱਟਣਾ ਸ਼ੁਰੂ ਕਰ ਰਿਹਾ ਹੈ, ਰੁਕਣਾ ਪੈਸੇ ਸਾੜਨ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਮਝਦਾਰੀ ਵਾਲਾ ਹੈ।
• ਸਸਤੇ ਮਾਡਲ ਗੰਦੇ ਕੰਮ ਕਰਦੇ ਹਨ, ਮਹਿੰਗੇ ਮਾਡਲ ਨਾਜ਼ੁਕ ਕੰਮ ਕਰਦੇ ਹਨ: ਲਾਗਤ ਸੰਚਾਲਿਤ ਹੁੰਦੀ ਹੈ, ਪ੍ਰਾਰਥਨਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਪ੍ਰੋਜੈਕਟ ਐਡਰੈੱਸ: https://github.com/subsy/ralph-tui