46 రిపోజిటరీల ద్వారా ఒకే నాలెడ్జ్ గ్రాఫ్ను నిర్మించడం
నేను రైయన్, airCloset లో CTO.
నేను code-graph నిర్మించడానికి మూడు నెలలు కేటాయించాను. ఇది బహుళ సర్వీసుల ద్వారా 46 రిపోజిటరీలను ఏకం చేసే ఒకే ఒక నాలెడ్జ్ గ్రాఫ్.
చాలా మంది మీ కోడ్నంతటినీ AIకి ఇచ్చి ప్రశ్నలు అడగవచ్చని అనుకుంటారు. ఇది రెండు కారణాల వల్ల విఫలమవుతుంది:
- Context windows: 46 రిపోజిటరీల నుండి సంవత్సరాల కొద్దీ ఉన్న కోడ్ను ఒకే ప్రాంప్ట్లో ఉంచలేరు.
- Hallucination: సంబంధాలను అంచనా వేయడానికి ప్రయత్నించినప్పుడు AI తప్పులు చేస్తుంది. ఇది కనెక్షన్లను మిస్ అవుతుంది.
దీనిని పరిష్కరించడానికి, నేను ఒక source of truthను నిర్మించడానికి static analysisని ఉపయోగించాను.
సవాలు: సరిహద్దులను దాటడం (Crossing Boundaries)
ఒక పెద్ద codebase గందరగోళంగా ఉంటుంది. ఒక APIని ఐదు వేర్వేరు రిపోజిటరీల నుండి పిలవవచ్చు. ఒక డేటాబేస్ టేబుల్ను మూడు వేర్వేరు సర్వీసుల ద్వారా ఉపయోగించవచ్చు.
మీరు కేవలం ఒక రిపోజిటరీని మాత్రమే చూస్తే, పూర్తి చిత్రాన్ని చూడలేరు. ఇది ప్రమాదకరం. మీరు కోడ్ను మార్చినప్పుడు దాని వల్ల కలిగే అసలు ప్రభావాన్ని (blast radius) గమనించకపోతే, సిస్టమ్ దెబ్బతింటుంది.
నా విధానం కోడ్ను syntax treesగా పార్స్ చేయడానికి tree-sitterని ఉపయోగిస్తుంది. కానీ tree-sitter మాత్రమే రిపోజిటరీ సరిహద్దుల అవతల ఉన్న వాటిని చూడలేదు.
దీనిని పరిష్కరించడానికి నేను boundary nodesలను నిర్మించాను.
ఇది ఎలా పనిచేస్తుంది:
- మేము tree-sitter ఉపయోగించి ఒక రిపోజిటరీలోని సంబంధాలను సంగ్రహిస్తాము.
- types మరియు variablesలను పరిష్కరించడానికి మేము TypeScript Compiler APIని ఉపయోగిస్తాము.
- టూల్స్ గుర్తించలేని డైనమిక్ కేసులను హ్యాండిల్ చేయడానికి మేము Geminiని ఉపయోగిస్తాము.
AIని ఊహించమని అడిగే బదులు, మేము దానికి వాస్తవాలను అందిస్తాము. మేము దానికి ఇలా చెబుతాము: "ఈ APIని Repo X నుండి కూడా పిలుస్తున్నారు." ఇది hallucinationలను నివారిస్తుంది.
కష్టమైన భాగం: ఫ్రేమ్వర్క్ జూ (The Framework Zoo)
ఈ సరిహద్దులను (boundaries) సంగ్రహించడమే అసలైన పోరాటం. ప్రతి ఫ్రేమ్వర్క్ సరిహద్దులను భిన్నంగా రాస్తుంది.
ఒక టీమ్ NestJS decorators ఉపయోగిస్తుంది. మరొకరు Express routes ఉపయోగిస్తారు. ఇంకొకరు raw jQuery ఉపయోగిస్తారు. ప్రతిదీ కోడ్లో ఒక విభిన్నమైన నిర్మాణాన్ని సృష్టిస్తుంది.
ఇది పనిచేయడానికి, మేము వీటి కోసం కస్టమ్ పార్సర్లను నిర్మించాల్సి వచ్చింది:
- NestJS మరియు TypeORM
- Express మరియు Fastify
- AngularJS మరియు Redux
- వివిధ path-alias schemes
మేము 99% ఖచ్చితత్వాన్ని లక్ష్యంగా పెట్టుకోవాల్సి వచ్చింది. మా కనెక్షన్ రేటు కేవలం 90% మాత్రమే ఉంటే, AI 10% కనెక్షన్లను మిస్ అవుతుంది. ప్రొడక్షన్ సిస్టమ్లో, ఆ 10%లోనే బగ్స్ దాగి ఉంటాయి.
మేము ఇప్పుడు ప్రతిరోజూ ఒక చెక్ నిర్వహిస్తాము. మా కనెక్షన్ రేటు 5% కంటే ఎక్కువ తగ్గితే, మాకు అలర్ట్ వస్తుంది. కొత్త కోడ్ ప్యాటర్న్లు మా పార్సర్లను దెబ్బతీసినప్పుడు ఇది గుర్తిస్తుంది.
ప్రస్తుత పరిమితులు
గ్రాఫ్ పరిపూర్ణంగా లేదు.
- సెర్చ్ చేయడం కష్టం. మీ సెర్చ్ ప్రారంభించడానికి తరచుగా మీకు ఒక ఫంక్షన్ పేరు తెలియాలి.
- Node explosion. ఒక పాత్ను అనుసరించడం వల్ల వేల సంఖ్యలో చిన్నవి, ఉపయోగం లేని హెల్పర్ ఫంక్షన్లు వస్తాయి.
- మెయింటెనెన్స్. మా స్టాక్లోకి ప్రతిసారీ కొత్త ఫ్రేమ్వర్క్ వచ్చినప్పుడు, మేము కొత్త పార్సర్ను వ్రాయాలి.
ఇది పార్ట్ 1. పార్ట్ 2లో, ఈ లోపాలను సరిదిద్దడానికి నేను నిర్మించిన service-product-graph (SPG) లేయర్ గురించి చర్చిస్తాను.
Optional learning community: https://t.me/GyaanSetuAi