டெர்மினல் AI-க்கான தானாகவே புதுப்பிக்கப்படும் அறிவுத் தளம்

எனது பெரும்பாலான நேரத்தை ஒரு AI கோடிங் உதவியாளருடன் டெர்மினலில் செலவிடுகிறேன்.

ஒரு அமர்வின் (session) போது நான் அடிக்கடி கடினமான சிக்கல்களைத் தீர்க்கிறேன். ஒரு சிக்கலான தீர்வை அல்லது ஒரு குறிப்பிட்ட கான்ஃபிகரேஷன் அமைப்பைக் கண்டறிகிறேன். பிறகு அந்தத் தாவலை (tab) மூடிவிடுகிறேன், அப்போது அந்த அறிவு காணாமல் போய்விடுகிறது. ஒரு மாதம் கழித்து, அதே சிக்கலை மீண்டும் தீர்க்கிறேன்.

Claude Code hooks பயன்படுத்தி, எனது உதவியாளரே தனது சொந்தக் குறிப்புகளைப் பராமரிக்கும் வகையில் ஒரு அமைப்பை நான் உருவாக்கினேன்.

இந்த அமைப்பு மூன்று பகுதிகளைப் பயன்படுத்துகிறது:

  • சூழலை (context) வழங்க, ஒவ்வொரு ப்ராம்ப்ட் (prompt) செய்யும் போதும் ஒரு சிறிய Markdown அறிவுத் தளத்தைத் தேடுதல்.
  • ஒரு அமர்வு முடிவடையும் போது பயனுள்ள குறிப்புகளைப் பதிவு செய்தல்.
  • ஒரு அமர்வு தொடங்கும் போது குறியீட்டை (index) ஏற்றுதல்.

உங்கள் பணிப்பாய்வை (workflow) மெதுவாக்காமல் இதை எவ்வாறு உருவாக்குவது என்பது இதோ.

  1. மீட்டெடுப்பிற்கு (retrieval) UserPromptSubmit-ஐப் பயன்படுத்தவும்

நீங்கள் ஒரு ப்ராம்ப்ட் அனுப்பும் ஒவ்வொரு முறையும் இந்த ஹூக் (hook) இயங்கும். இது உங்கள் உரையைப் பெற்று, மாடல் பதிலளிப்பதற்கு முன் சூழலைச் சேர்க்கும் (inject).

உங்கள் குறிப்புகளை எப்போது பார்க்க வேண்டும் என்பதை மாடலையே தீர்மானிக்க விடாதீர்கள். தொடர்புடைய கோப்புகளைக் கண்டறிய grep போன்ற வேகமான தேடலைப் பயன்படுத்தவும். முதல் ஐந்து பொருத்தமான முடிவுகளை மட்டும் சேர்க்கவும். இது செயல்முறையை 100ms-க்கும் குறைவாக வைத்திருக்க உதவும்.

தேடல் ஹூக்குகளுக்கான இரண்டு விதிகள்:

  • செலவைக் குறைக்கவும். ஆரம்பத் தேடலுக்கு LLM-க்கு பதிலாக grep-ஐப் பயன்படுத்தவும்.
  • சுருக்கமாக வைத்திருக்கவும். தலைப்புகள் மற்றும் கோப்புப் பாதைகளை (file paths) மட்டும் சேர்க்கவும். கூடுதல் விவரங்கள் தேவைப்பட்டால் மாடலே கோப்பைத் திறந்து கொள்ளலாம்.
  1. கடினமான பணிகளுக்கு Stop hook-ஐத் தவிர்க்கவும்

உதவியாளர் ஒரு பதிலைப் பூர்த்தி செய்யும் ஒவ்வொரு முறையும் Stop hook இயங்கும். நீங்கள் இங்கே ஒரு நீண்ட பணியைச் செய்தால், உங்கள் உதவியாளர் மெதுவாகிவிடும். 30 முறை உரையாடும் ஒரு அமர்வு, 30 கடினமான பணிகளைத் தூண்டும்.

அதற்குப் பதிலாக, முழு அமர்வையும் ஒரே ஒரு முறை பதிவு செய்ய SessionEnd-ஐப் பயன்படுத்தவும்.

  1. SessionEnd வரம்பைத் தீர்க்கவும்

SessionEnd என்பது blocking அல்ல (non-blocking). நீங்கள் இங்கே ஒரு நீண்ட பின்னணிப் பணியைத் (background task) தொடங்கினால், அமர்வு மூடும்போது சிஸ்டம் அதை நிறுத்திவிடக்கூடும்.

இதற்கான தீர்வு இரண்டு ஹூக்குகளைப் பயன்படுத்துவதாகும்:

  • SessionEnd: டிரான்ஸ்கிரிப்ட் பாதையை (transcript path) விரைவாக ஒரு வரிசை கோப்பிற்கு (queue file) சேர்க்கவும்.
  • SessionStart: அந்த வரிசையைச் சரிபார்த்து (drain), கடினமான பதிவுப் பணியை பின்னணியில் இயக்கவும்.

அடுத்த அமர்வு செயல்பாட்டில் இருப்பதால், பின்னணிச் செயல்முறை தொடர்ந்து இயங்கும்.

  1. முடிவில்லா சுழற்சிகளைத் (infinite loops) தவிர்க்கவும்

குறிப்புகளை எழுத நீங்கள் ஒரு headless AI-ஐ உருவாக்கும்போது, அது உங்கள் சூழலையே (environment) எடுத்துக்கொள்ளும். அதாவது, புதிய AI தனது சொந்த ஹூக்குகளைத் தூண்டும். இது முடிவில்லா AI அழைப்புகளின் சுழற்சியை உருவாக்கும்.

உங்கள் ஸ்கிரிப்ட்களின் தொடக்கத்தில் எப்போதும் ஒரு recursion guard-ஐச் சேர்க்கவும்:

[ -n "$KB_CAPTURE" ] && exit 0

உங்கள் பின்னணிப் பதிவுப் பணியைத் தொடங்கும் போது KB_CAPTURE=1 என அமைக்கவும்.

அமைப்பின் சுருக்கம்:

  • உடனடி சூழலைச் சேர்க்க UserPromptSubmit-ஐப் பயன்படுத்தவும்.
  • பணிகளை வரிசைப்படுத்த (enqueue) SessionEnd-ஐப் பயன்படுத்தவும்.
  • உண்மையான பணியைச் செய்ய SessionStart-ஐப் பயன்படுத்தவும்.
  • பணத்தைச் சேமிக்க, குறிப்புகளைச் சுருக்க மலிவான மாடலைப் பயன்படுத்தவும்.

ஒருமுறை மீண்டும் தீர்க்க வேண்டிய சிக்கலைத் தவிர்ப்பதே பலமுறை பதிவு செய்வதற்கான செலவை ஈடுகட்டிவிடும்.

Source: https://dev.to/just_an_electron/a-self-updating-knowledge-base-for-my-terminal-ai-assistant-claude-code-hooks-28jb

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