ഒരു വാരാന്ത്യത്തിനുള്ളിൽ ഞങ്ങൾ ഒരു സ്വയം പ്രവർത്തിക്കുന്ന കോഡ് ഗാർഡിയൻ നിർമ്മിച്ചു

ഞങ്ങൾ ഒരു വലിയ ലക്ഷ്യവുമായി JacHacks-ൽ പങ്കെടുത്തു.

ഒരു റിപ്പോസിറ്ററി നിരീക്ഷിക്കുന്ന ഒരു ടൂൾ നിർമ്മിക്കുക എന്നതാണ് ലക്ഷ്യം. സംശയാസ്പദമായ ഡിപെൻഡൻസി (dependency) മാറ്റങ്ങൾ അത് കണ്ടെത്തണം. അവ ദോഷകരമാണെന്ന് തെളിയിക്കുന്നതിനായി ഒരു sandbox-ൽ പ്രവർത്തിപ്പിക്കണം. തുടർന്ന്, ഒരു പരിഹാരം എഴുതി ഒരു pull request ഓപ്പൺ ചെയ്യണം. അവസാനം വരെ മനുഷ്യരുടെ ഇടപെടലുകൾ ആവശ്യമില്ല.

ഞങ്ങൾ ഇതിനെ GhostWatch എന്ന് വിളിച്ചു. ഏജന്റിക് ട്രാക്കിൽ (agentic track) ഇതിന് രണ്ടാം സ്ഥാനം ലഭിച്ചു.

ഞങ്ങൾ ഇത് എങ്ങനെ നിർമ്മിച്ചു എന്നും ഇതിൽ നിന്ന് എന്തൊക്കെ പഠിച്ചു എന്നും താഴെ നൽകുന്നു.

പ്രശ്നം

സാധാരണ കോഡ് റിവ്യൂകളിൽ രണ്ട് പ്രധാന പോരായ്മകളുണ്ട്:

  • ടൂളുകൾക്ക് 'ബ്ലാസ്റ്റ് റേഡിയസ്' (blast radius) കാണാൻ കഴിയില്ല. ഒരു ഫങ്ക്ഷനിലെ മാറ്റം ദൂരെയുള്ള ഫയലുകളെ പോലും ബാധിച്ചേക്കാം. മിക്ക ടൂളുകളും ഈ ബന്ധങ്ങൾ പരിശോധിക്കാറില്ല.
  • സപ്ലൈ ചെയിൻ ആക്രമണങ്ങൾ (Supply chain attacks) റിവ്യൂകളെ മറികടക്കുന്നു. ഒരു അറ്റാക്കർക്ക് വിഷലിപ്തമായ (poisoned) ഒരു വേർഷൻ നേരിട്ട് ഒരു രജിസ്ട്രിയിലേക്ക് എത്തിക്കാൻ കഴിയും. റിവ്യൂ ചെയ്യാൻ അവിടെ ഒരു pull request ഉണ്ടാകില്ല. നാശനഷ്ടങ്ങൾ സംഭവിച്ചതിന് ശേഷം മാത്രമേ നിങ്ങൾക്ക് ഇത് അറിയാൻ കഴിയൂ.

ഞങ്ങളുടെ പരിഹാരം

സ്പേഷ്യൽ അവയർനസ് (spatial awareness) ഉള്ള ഒരു സിസ്റ്റം ഞങ്ങൾ നിർമ്മിച്ചു. കോഡ്ബേസിനെ ഒരു ഗ്രാഫ് ആയി മോഡൽ ചെയ്യാൻ ഞങ്ങൾ Jac ഉപയോഗിച്ചു.

ഈ ഗ്രാഫിൽ:

  • ഫയലുകൾ നോഡുകളാണ് (nodes).
  • ഇംപോർട്ടുകൾ (imports) എഡ്ജുകളാണ് (edges).

ബ്ലാസ്റ്റ് റേഡിയസ് കണ്ടെത്താൻ ഞങ്ങൾ ഊഹങ്ങൾ നടത്താറില്ല. പകരം ഒരു ഗ്രാഫ് വാക്ക് (graph walk) നടത്തുന്നു. ഇത് സെക്യൂരിറ്റി ലോജിക് കൃത്യവും (deterministic) വിശദീകരിക്കാൻ കഴിയുന്നതുമാക്കുന്നു.

ടെക് സ്റ്റാക്ക്

പച്ചയായ Python-നും മാനുവൽ LLM കോളുകൾക്കും പകരം ഞങ്ങൾ Jac ഉപയോഗിച്ചു. ഇത് ഞങ്ങളുടെ പ്രവർത്തനരീതിയെ മാറ്റിമറിച്ചു:

  • കോഡ്ബേസ് തന്നെ ഡാറ്റാ സ്ട്രക്ചറാണ്.
  • പെർസിസ്റ്റൻസ് (Persistence) ഇതിൽ ഇൻബിൽറ്റ് ആണ്. ഒരു പ്രത്യേക ഡാറ്റാബേസ് ഇല്ലാതെ തന്നെ ഞങ്ങളുടെ റിപ്പോ ഗ്രാഫ് റീസ്റ്റാർട്ടുകൾക്ക് ശേഷവും നിലനിൽക്കുന്നു.
  • LLM ഇന്റഗ്രേഷൻ വളരെ എളുപ്പമാണ്. ഒരു ഫങ്ക്ഷനെ ടൈപ്പ് ചെയ്ത ഒബ്ജക്റ്റുകൾ (typed objects) തിരികെ നൽകുന്ന ഒരു LLM കോളാക്കി മാറ്റാൻ ഞങ്ങൾ ഒരു കീവേഡ് മാത്രം ഉപയോഗിക്കുന്നു.

പ്രയാസകരമായ ഭാഗങ്ങൾ

ഇത് എളുപ്പമായിരുന്നില്ല. ഞങ്ങൾ പല തടസ്സങ്ങളും നേരിട്ടു:

  • പുതിയ സിന്റാക്സ്: Python-ലെ "self"-ന് പകരം Jac സെമി കോളനുകൾ, ബ്രേസുകൾ, കൂടാതെ "has" പോലുള്ള പ്രത്യേക കീവേഡുകൾ ഉപയോഗിക്കുന്നു. പാഴ്സ് എററുകൾ (parse errors) പരിഹരിക്കാൻ ആദ്യത്തെ കുറച്ച് മണിക്കൂറുകൾ ഞങ്ങൾക്ക് ചെലവഴിക്കേണ്ടി വന്നു.
  • React-ലെ കുഴപ്പങ്ങൾ: ലിസ്റ്റുകൾ നേരിട്ട് മാറ്റാൻ (mutate) ഞാൻ ശ്രമിച്ചു. ഇത് ഫ്രണ്ട്‌എൻഡ് അപ്‌ഡേറ്റ് ആകുന്നത് തടഞ്ഞു. റീ-റെൻഡറുകൾ (re-renders) ലഭ്യമാക്കുന്നതിനായി ലിസ്റ്റുകൾ റീ-അസൈൻ ചെയ്യേണ്ടി വന്നു.
  • ഡോക്യുമെന്റേഷനിലെ കുറവുകൾ: ചില ഡോക്യുമെന്റേഷനുകൾ അപൂർണ്ണമായതിനാൽ എൻവയോൺമെന്റ് സെറ്റപ്പ് ചെയ്യാൻ പ്രതീക്ഷിച്ചതിലും കൂടുതൽ സമയം എടുത്തു.

എന്തുകൊണ്ട് ഇത് പ്രധാനമാണ്

മിക്ക ഏജന്റ് സിസ്റ്റങ്ങളിലും സ്റ്റേറ്റ് (state), ഓർക്കസ്ട്രേഷൻ (orchestration), സീരിയലൈസേഷൻ (serialization) എന്നിവ മാനുവലായി കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്. എന്നാൽ Jac ഉപയോഗിക്കുമ്പോൾ, ഗ്രാഫ് എന്നത് ഒരു ലാംഗ്വേജ് കൺസ്ട്രക്റ്റാണ് (language construct). ഞങ്ങൾ പരിഹരിക്കാൻ ശ്രമിച്ച പ്രശ്നത്തിന് അനുയോജ്യമായ രീതിയിലാണ് സിസ്റ്റം ആർക്കിടെക്ചർ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

ഈ പ്രോജക്റ്റ് പൂർണ്ണമല്ല. സാൻഡ്‌ബോക്സിൽ ക്ലൗഡ് മൈക്രോ വിഎം-കൾക്ക് (cloud microVMs) പകരം ലോക്കൽ സബ്പ്രോസസുകളാണ് ഉപയോഗിക്കുന്നത്. ഹാക്കത്തോൺ പ്രോജക്റ്റുകൾ കപടമായ തിളക്കം കാണിക്കരുത് എന്നതുകൊണ്ട് ഞങ്ങൾ ഈ പോരായ്മകൾ വ്യക്തമായി തന്നെ വെച്ചു.

ഡെമോ കാണുക: https://www.youtube.com/watch?v=ZN0UVnNUpRs

കോഡ് പരിശോധിക്കുക: https://github.com/ayushmk7/GhostWatch

Source: https://dev.to/ayushmk/we-built-an-autonomous-code-guardian-in-a-weekend-heres-what-happened-4982

Optional learning community: https://t.me/GyaanSetuAi